Os 3 principais clientes HTTP Python para Web Scraping

Mihnea-Octavian Manolache em Dec 02 2022

Quando se trata de raspagem da web, a variedade de clientes HTTP python disponíveis faz do Python uma das escolhas mais populares. Mas o que são exatamente estes clientes HTTP e como é que os pode usar para construir um web scraper? Bem, no artigo de hoje vamos discutir exatamente este tópico. No final deste artigo, deverá ter uma sólida compreensão sobre:

O que é um cliente HTTP em geral
Quais são os melhores clientes HTTP python em 2022
Porque é que o Python é uma óptima escolha para a recolha de dados da Web
Como criar efetivamente um raspador da Web utilizando clientes HTTP

O que são clientes HTTP Python e como usá-los

Para entender melhor como a internet se comunica, é preciso se familiarizar com o Protocolo de Transferência de Hipertexto (HTTP). No entanto, nosso foco principal para hoje reside em torno de clientes HTTP em python. Por isso, vou assumir que já estás familiarizado com o HTTP.

Em termos gerais, um cliente HTTP refere-se a uma instância ou a um programa que facilita a comunicação com um servidor. Por exemplo, um navegador da Web pode ser considerado um cliente HTTP. No entanto, como programadores, raramente usamos um browser real quando construímos uma aplicação, exceto quando estamos a trabalhar num web scraper ou quando estamos a fazer a nossa pesquisa.

Dito isto, quando nos referimos a clientes HTTP de uma forma mais programática, normalmente referimo-nos a um método ou a uma instância de uma classe usada para executar pedidos HTTP. Como Python é, sem dúvida, uma das linguagens de programação mais populares (e também a minha favorita), hoje vamos discutir os melhores clientes HTTP Python e também como implementá-los num projeto real.

Compreender o protocolo HTTP

Antes de avançar, embora eu recomende que se consulte a documentação do HTTP, deixe-me passar rapidamente por alguns dos conceitos básicos do HTTP. Em primeiro lugar, o HTTP é talvez um dos protocolos de Internet mais utilizados. Nós o usamos todos os dias para trocar informações entre clientes e servidores.

Para que tal seja possível, o HTTP utiliza métodos de pedido. Estes métodos indicam a ação que um cliente pretende realizar num servidor. Por exemplo, se quiser obter alguma informação de um servidor, deve utilizar GET. Se pretender enviar algo para o servidor, deve utilizar POST. Segue-se uma lista dos métodos de pedido HTTP mais comuns:

GET - obter dados do servidor
HEAD - recupera apenas o cabeçalho, sem o corpo (os dados reais)
POST - Enviar algumas informações para o servidor
PUT - Enviar informações para o servidor e substituir todas as representações actuais do recurso
PATCH - Enviar informações para o servidor e modificar parcialmente o recurso
DELETE - Elimina o recurso do servidor

Porquê Python para pedidos HTTP

Em primeiro lugar, Python tem uma óptima sintaxe e uma comunidade ainda maior. Por isso, é perfeito para aprender. Eu próprio, quando comecei a programar, escolhi Python. De facto, os clientes HTTP Python foram das primeiras tecnologias com que me cruzei. Mas isso é outro assunto.

O meu objetivo para o artigo de hoje é garantir que sai não só com uma compreensão teórica básica, mas também com uma visão geral da implementação prática.

E Python é ótimo para ambos por várias razões. Só para citar algumas:

Sintaxe - Escrever Python é muito parecido com escrever inglês. Por isso, ler um script Python vai ajudar-te a relacionar conceitos teóricos com a sua implementação real.
Suporte - Python tem uma comunidade muito grande. Na maioria das vezes, se estiveres preso, uma simples pergunta no StackOverflow revelará a resposta para o teu problema.
Disponibilidade - A biblioteca de pacotes Python está entre as mais extensas. Por exemplo, apenas no que diz respeito aos clientes HTTP Python, existem mais de uma dúzia de pacotes. Mas, por hoje, vamos concentrar-nos nos mais populares.

3(+1) Melhores clientes HTTP Python

Quando se trata de categorizar pacotes para chegar a um top 3 dos melhores clientes HTTP Python, eu acredito que é tanto uma questão de funcionalidade quanto de preferência pessoal. Então é correto dizer que o seguinte representa meu top 3 de bibliotecas clientes HTTP para Python, ao invés de um ranking geral.

1. Pedidos - Simplicidade poderosa

Requests é provavelmente um dos clientes HTTP mais preferidos na comunidade Python. Eu não faço exceção. Sempre que eu testo um novo web scraper, eu uso Python com Requests. É tão fácil quanto dizer .get e tão poderoso quanto um navegador web de verdade.

Entre outras coisas, a biblioteca de pedidos oferece:

Verificação SSL
Suporte de proxy para HTTPS
Persistência de cookies e sessões
Funcionalidade manter vivo
Autenticação personalizada

E estas são apenas algumas. Pode consultar a lista completa de funcionalidades aqui. Agora vou mostrar-lhe como trabalhar com pedidos:

importar pedidos
r = requests.get("http://google.com") 
print(r.test)

Como pode ver, com apenas 3 linhas de código, a biblioteca requests ajuda-nos a recolher a linha HTML de um servidor. No exemplo acima, estamos a fazer um pedido GET ao servidor e estamos a imprimir o resultado. Mas, como eu disse, essa biblioteca é muito mais diversificada. Vamos criar um exemplo mais complexo, que use recursos como proxies e solicitações POST:

import requests

def get_params(object):
    params = ''
    for key,value in object.items():
        if list(object).index(key) < len(object) - 1:
            params += f"{key}={value}."
        else:
            params += f"{key}={value}"
    return params

API_KEY = '<YOUR_API_KEY>'

TARGET_URL = 'https://httpbin.org/post'

DATA = {"foo":"bar"}

PARAMETERS = {
    "proxy_type":"datacenter",
    "device":"desktop"
}

PROXY = {
    "http": f"http://webscrapingapi.{ get_params(PARAMETERS) }:{ API_KEY }@proxy.webscrapingapi.com:80",
    "https": f"https://webscrapingapi.{ get_params(PARAMETERS) }:{ API_KEY }@proxy.webscrapingapi.com:8000"
}

response = requests.post(
    url=TARGET_URL,
    data=DATA,
    proxies=PROXY,
    verify=False
)

print(response.text)

Vejamos o que estamos a fazer aqui:

Estamos a definir a função `get_params`, que recebe um objeto e o devolve como uma cadeia de parâmetros URL.
Estamos a definir as nossas variáveis:
undefinedundefinedundefinedundefinedundefinedundefined
Estamos usando o método `post` de Requests para enviar uma solicitação de postagem HTTP.
Estamos a imprimir o corpo da resposta

2. HTTPX - Pedidos reinventados

HTTPX é relativamente novo na cena. No entanto, em pouco tempo ele se tornou um dos clientes HTTP Python mais recomendados. Por exemplo, o Flask (um dos maiores frameworks web para Python) recomenda o uso do HTTPX em sua documentação oficial.

Quando eu disse que HTTPX é requests reinventado, foi porque as duas bibliotecas são muito semelhantes em termos de sintaxe. Na verdade, HTTPX tem como objetivo a compatibilidade total com requests. Existem apenas algumas pequenas diferenças de design entre as duas, que são destacadas aqui.

Eis o aspeto de um pedido POST básico em HTTPX:

import httpx

TARGET_URL = 'https://httpbin.org/post'

DATA = {"foo":"bar"}

r = httpx.post(
   url=TARGET_URL,
   data=DATA,
)

print(r.text)

Como pode ver, é principalmente o nome do pacote que estamos a alterar, em comparação com o exemplo Requests. E já que eles são tão parecidos, a pergunta que fica é: por que escolher HTTPX ao invés de Requests? Bem, para começar, HTTPX é um dos poucos clientes HTTP Python que oferece suporte assíncrono. Resumindo, HTTPX é uma ótima escolha se você quer refatorar seu código baseado em requests.

3. urllib3 - Conexões seguras para threads

Python tem um par de 'urllibs', o que normalmente confunde os novos programadores. A principal diferença entre urllib, urllib2 e urllib3 está nas caraterísticas de cada pacote. urllib era o cliente HTTP original do Python, incluído na biblioteca padrão do Python 1.2. urllib2 era a versão atualizada, introduzida no Python 1.6 e tinha como objetivo substituir a urllib original.

Quando se trata da urllib3, no entanto, ela é na verdade um cliente HTTP Python de terceiros. Apesar do seu nome, esta biblioteca não está relacionada com as duas 'predecessoras'. Além disso, a comunidade Python diz que não há intenção de incluir a urllib3 na biblioteca padrão. Pelo menos num futuro próximo.

Embora este pacote não esteja oficialmente ligado à biblioteca padrão do Python, muitos programadores utilizam-no porque oferece:

Segurança da linha
Verificação SSL / TLS do lado do cliente
Suporte de proxy para HTTP e SOCKS
Cobertura completa dos testes

Agora que já abordámos a parte teórica, vamos ver o exemplo de implementação:

import urllib3,json

TARGET_URL = 'https://httpbin.org/post'

DATA = {"foo":"bar"}

http = urllib3.PoolManager()

encoded_data = json.dumps(DATA)

r = http.request('POST', TARGET_URL, body=encoded_data)   

print(r.data.decode('utf-8'))

Vamos discutir as diferenças identificadas na urllib3, por oposição à Requests:

`http` - uma instância do método `PoolManager`, que lida com os detalhes de segurança de thread e pooling de conexão
`encoded_data` - uma cadeia JSON convertida, que contém a carga útil que estamos a enviar
`r` - o pedido POST atual que estamos a fazer com a ajuda da urllib3. Aqui, estamos usando o método `request` da instância `PoolManager`.

E, no final, temos de descodificar os dados que estamos a receber do nosso pedido. Como você pode ver, há algumas coisas que estamos fazendo de forma diferente do que com Requests.

Menção Honrosa: http.client - Cliente HTTP tradicional em Python

http.client também faz parte da biblioteca padrão do Python. Tradicionalmente, não é usado diretamente pelos programadores. Por exemplo, a urllib usa-o como uma dependência, para lidar com pedidos HTTP e HTTPS. Eu a incluí em nosso ranking porque acho que, como programadores, é bom conhecer os 'ossos' dos pacotes que estamos usando.

Por isso, mesmo que não cries um projeto real com http.client, aqui está um exemplo de implementação que te vai ajudar a perceber melhor como funcionam os clientes HTTP Python:

import http.client

TARGET_URL = 'www.httpbin.org'

http = http.client.HTTPSConnection(TARGET_URL)
http.request("GET", "/get")

r = http.getresponse()

print(r.read().decode('utf-8'))

A instância `HTTPSConnection` recebe alguns parâmetros, que podem ser verificados aqui. No nosso exemplo, estamos definindo apenas o `method` e o `url` (ou mais precisamente, o endpoint). Além disso, assim como na urllib3, o http.client retorna uma resposta codificada. Então nós precisamos decodificá-la antes de imprimir.

Caso de uso: Criando um Scraper com solicitações

Agora que sabemos como utilizar clientes HTTP, vamos atribuir a nós próprios um pequeno projeto. Será útil não só para aplicar o que aprendeu, mas também para acrescentar algum valor ao seu próprio portefólio de programação.

Uma vez que os clientes HTTP em Python são normalmente utilizados para recolher informação dos servidores, a utilização mais comum destas tecnologias é a criação de um web scraper. Por isso, vamos focar-nos em como criar um web scraper usando clientes HTTP em Python. Como tenho um favorito pessoal - requests - vou usá-lo para este projeto. No entanto, você pode usá-lo como um ponto de partida e até mesmo ajustá-lo para usar algumas das outras tecnologias que discutimos. Sem mais delongas, vamos começar a programar:

1. Configuração do projeto

Vamos começar por criar um novo diretório no qual iremos guardar os ficheiros para o nosso web scraper. Agora abra uma nova janela de terminal e `cd` nesse diretório. Aqui, nós queremos iniciar um novo ambiente virtual. Se você estiver num sistema operacional do tipo UNIX, você pode usar:

~ " python3 -m venv env && source env/bin/activate

Agora, basta criar um novo ficheiro Python que conterá a nossa lógica e abri-lo no IDE pretendido. Se quiser usar o terminal, basta colar o seguinte comando:

~ " touch scraper.py && code .

2. Instalação de dependências

Utilizaremos o pip para instalar os pacotes necessários para este projeto. Para já, estabelecemos que vamos utilizar o Requests, mas isso não é suficiente para um web scraper. Um web scraper também implica o tratamento dos dados. Isto significa que precisamos de analisar o HTML recolhido dos servidores. Felizmente, a biblioteca Python oferece uma grande variedade de pacotes. No entanto, para este projeto, vamos utilizar o BeautifulSoup. Para instalar os pacotes, basta colar o seguinte comando:

~ " python3 -m pip install requests bs4

3. Escrever a lógica

Vamos dividir o nosso código em duas secções: uma para extração de dados e outra para manipulação de dados. A primeira parte é coberta pelo pacote Requests, enquanto a segunda parte é coberta pelo BeautifulSoup. Sem mais demoras, vamos começar a codificar, começando pela parte da extração:

import requests

def scrape( url = None ):
  # se não houver URL, não há necessidade de usar clientes HTTP Python
 # Vamos imprimir uma mensagem e parar a execução
 if url == None:
 print('[!] Please add a target!')
 return

 response = requests.get( url ) 
 return response

Nesta secção, vamos definir uma função com apenas um parâmetro: o URL de destino. Se o URL não for fornecido, vamos imprimir uma mensagem e parar a execução. Caso contrário, estamos a utilizar o método get de Request para devolver a resposta. Agora, sabemos que os clinetts HTTP do Python cobrem mais métodos, então vamos adicionar um parâmetro condicional:

import requests

def scrape( method = 'get', url = None, data = None ):
  # se não existir um URL, não é necessário utilizar clientes HTTP Python
 # Vamos imprimir uma mensagem e parar a execução
 if url == None:
 print('[!] Please add a target!')
 return

 if method.lower() == 'get':
 response = requests.get( url )

 elif method.lower() == 'post':
 if data == None:
 print('[!] Please add a payload to your POST request!')
 return
 response = requests.post( url, data )
      
 return response

Como pode ver, adicionámos mais alguns parâmetros à nossa função. O parâmetro `method` especifica qual método deve ser usado para nossa solicitação. O parâmetro `data` representa o payload que estamos a enviar com o pedido POST. Por padrão, o método é GET, portanto, o parâmetro `method` não é necessário.

Desafio: Adicionar mais métodos a esta função e enriquecer as capacidades do nosso raspador. Não só é divertido, como também é uma boa abordagem de aprendizagem. Além disso, podes tornar o código teu, para que o possas adicionar ao teu portefólio.

Até agora, abordámos a extração de dados. Vamos analisar o HTML e fazer alguma coisa com ele:

from bs4 import BeautifulSoup

def extract_elements(data = None, el = None):
 if data == None:
 print('[!] Please add some data!')
 return

 if el == None:
 print('[!] Please specify which elements you are targeting!')
 return

 soup = BeautifulSoup(data.text, 'html.parser')
 elements = soup.find_all(el)

 return elements

Mas um web scraper deve ser capaz de extrair dados mais específicos. Por exemplo, deve ser capaz de localizar e devolver elementos com base no seu seletor CSS. Portanto, vamos adicionar a lógica que lida com essa parte:

from bs4 import BeautifulSoup

def extract_elements(data = None, el = None, attr = None, attr_value = None):
   if data == None:
       print('[!] Please add some data!')
       return

   if el == None:
       print('[!] Please specify which elements you are targeting!')
       return

   soup = BeautifulSoup(data.text, 'html.parser')
   elements = soup.find_all(el, { attr : attr_value })

   return elements

A BeautifulSoup permite-nos extrair dados específicos com base nos seus atributos. Assim, aqui adicionámos dois novos parâmetros que nos ajudarão a localizar e extrair elementos com base nos seus atributos.

Agora temos tudo o que precisamos. Tudo o que falta fazer é combinar as duas secções e temos o nosso web scraper. Depois de montares o teu código, basta:

Crie uma nova variável que reterá os dados extraídos com Requests
Imprimir os elementos devolvidos por BeautifulSoup

Aqui estão as duas partes do seu código que faltam:

data = scrape('GET', 'https://webscrapingapi.com')
print( extract_elements(data, 'ul') )

Tenho certeza que você já entendeu o que tudo faz e não há necessidade de uma tradução neste momento. Tal como no nosso scraper, desafio-o a brincar com a função `extract_elements` e a fazer mais do que simplesmente devolver elementos.

Conclusão

Quando se aprende um novo conceito de programação, penso que é melhor testar as diferentes tecnologias disponíveis. No entanto, quando se trata de construir a infraestrutura para um projeto mais vasto, é melhor conhecer os pontos fortes e fracos de cada tecnologia, antes de escolher uma.

Espero que este artigo te tenha ajudado de qualquer forma e que agora tenhas uma sólida compreensão de como os clientes HTTP Python funcionam. Também te encorajo a brincar, pois tenho a certeza que vais descobrir o pacote certo para ti.