visão geral
Web crawler é uma tecnologia para obter automaticamente dados da web, que podem ser usados para análise de dados, recuperação de informações, inteligência competitiva, etc. Enfrentando muitos desafios, como conteúdo Javascript carregado dinamicamente, mecanismo anti-crawler, atraso de rede, limitações de recursos, etc. Técnicas avançadas de rastreamento para resolver esses problemas incluem navegador automatizado Selenium, rastreamento multithread e distribuído.
Selenium é uma ferramenta de teste automatizado de código aberto que pode simular operações do usuário em um navegador, como abrir páginas da web, clicar em links e inserir texto. Suporta vários navegadores, como Firefox, Chrome, IE, etc. O Selenium retorna ao código-fonte da página da web após aguardar a execução do Javascript, manipula facilmente o conteúdo carregado dinamicamente e ignora mecanismos simples anti-rastreador, como códigos de verificação e cookies.
Multithreading é uma técnica de programação que permite aos programas executar múltiplas tarefas simultaneamente, melhorando a eficiência e o desempenho. Os rastreadores multithread podem rastrear várias páginas da web ao mesmo tempo, reduzindo o atraso da rede e o tempo de espera. O design e o gerenciamento razoáveis de pools de threads, filas e bloqueios são necessários para evitar problemas como segurança de threads, competição de recursos e consumo de memória.
Distribuído é uma arquitetura de sistema que divide uma tarefa grande em várias subtarefas pequenas e as executa em paralelo em computadores diferentes. Os rastreadores distribuídos aproveitam ao máximo os vários recursos do computador, aumentando a escala e a velocidade. Precisa usar frameworks e ferramentas profissionais, como Scrapy, Celery, Redis, etc., para resolver problemas de complexidade e sobrecarga.
texto
Neste artigo, apresentaremos como usar o Selenium para automatizar o rastreamento multithread e distribuído de conteúdo Javascript no navegador Firefox. Tomaremos um exemplo simples para obter os títulos e links na página de resultados de pesquisa do Baidu e salvar os resultados em um arquivo local. Codificaremos em Python e usaremos um servidor proxy rastreador para ocultar nosso endereço IP real.
Primeiro, precisamos instalar a biblioteca Selenium e o navegador Firefox, baixar a versão correspondente do driver geckodriver e colocá-lo na variável de ambiente Python. Então, precisamos importar os seguintes módulos:
# 导入模块
import requests
import threading
import queue
import time
from selenium import webdriver
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
from selenium.webdriver.common.proxy import Proxy, ProxyType
Em seguida, precisamos definir uma função para criar um objeto de navegador Firefox automatizado Selenium e definir o servidor proxy do rastreador e outros parâmetros:
# 创建浏览器对象并设置爬虫代理服务器
def create_browser():
# 亿牛云 爬虫代理加强版 代理服务器
proxyHost = "www.16yun.cn"
proxyPort = "31111"
# 代理验证信息
proxyUser = "16YUN"
proxyPass = "16IP"
# 设置代理服务器
proxy = Proxy()
proxy.proxy_type = ProxyType.MANUAL
proxy.http_proxy = proxyHost + ":" + proxyPort
proxy.ssl_proxy = proxyHost + ":" + proxyPort
# 设置代理验证信息
proxy.add_to_capabilities(DesiredCapabilities.FIREFOX)
# 创建浏览器对象
browser = webdriver.Firefox()
# 设置浏览器窗口大小
browser.set_window_size(800, 600)
# 设置浏览器超时时间
browser.set_page_load_timeout(10)
# 设置浏览器代理验证信息
browser.get("http://t.16yun.cn:31111")
browser.find_element_by_id("username").send_keys(proxyUser)
browser.find_element_by_id("password").send_keys(proxyPass)
browser.find_element_by_id("submit").click()
# 返回浏览器对象
return browser
Então, precisamos definir uma função para pegar o título e o link de uma página web e salvar o resultado em um arquivo local:
# 抓取一个网页的标题和链接，并将结果保存到本地文件中
def crawl_page(browser, url, file):
# 打开网页
browser.get(url)
# 获取网页标题和链接
titles = browser.find_elements_by_xpath("//h3[@class='t']/a")
links = [title.get_attribute("href") for title in titles]
# 将结果写入文件中
with open(file, "a", encoding="utf-8") as f:
for title, link in zip(titles, links):
f.write(title.text + "\t" + link + "\n")
A seguir, precisamos definir uma função para gerar a lista de URLs da página de resultados de pesquisa do Baidu. Usaremos "Selenium" como palavra-chave para obter os resultados das primeiras 10 páginas:
# 生成百度搜索结果页面的URL列表
def generate_urls(keyword, pages):
# 定义URL列表
urls = []
# 定义百度搜索结果页面的基本URL
base_url = "https://www.baidu.com/s?wd=" + keyword
# 循环生成URL列表
for page in range(1, pages + 1):
# 定义每一页的URL参数
params = "&pn=" + str((page - 1) * 10)
# 拼接完整的URL并添加到列表中
url = base_url + params
urls.append(url)
# 返回URL列表
return urls
A seguir, precisamos definir uma função para executar a lógica principal do rastreador multithread. Usaremos um pool de threads para gerenciar vários objetos do navegador e usaremos uma fila para armazenar a lista de URLs a serem rastreados:
# 执行多线程爬虫的主要逻辑
def run_crawler(keyword, pages, threads, file):
# 生成百度搜索结果页面的URL列表
urls = generate_urls(keyword, pages)
# 创建一个队列来存储待抓取的URL列表，并将URL添加到队列中
q = queue.Queue()
for url in urls:
q.put(url)
# 创建一个线程池来管理多个浏览器对象，并创建对应数量的浏览器对象并添加到线程池中
pool = []
for i in range(threads):
browser = create_browser()
pool.append(browser)
# 定义一个函数来执行每个线程的任务，即从队列中获取一个URL，并使用一个浏览器对象来抓取该网页，并将结果保存到本地文件中，然后释放该浏览器对象，并重复该过程，直到队列为空或出现异常
def worker():
while True:
try:
# 从队列中获取一个URL，如果队列为空，则退出循环
url = q.get(block=False)
except queue.Empty:
break
try:
# 从线程池中获取一个浏览器对象，如果线程池为空，则退出循环
browser = pool.pop()
except IndexError:
break
try:
# 使用浏览器对象来抓取该网页，并将结果保存到本地文件中
crawl_page(browser, url, file)
except Exception as e:
# 打印异常信息
print(e)
finally:
# 将浏览器对象放回线程池中
pool.append(browser)
# 创建一个空列表来存储多个线程对象，并创建对应数量的线程对象并添加到列表中，并启动每个线程
threads = []
for i in range(threads):
t = threading.Thread(target=worker)
threads.append(t)
t.start()
# 等待所有线程结束
for t in threads:
t.join()
# 关闭所有浏览器对象
for browser in pool:
browser.quit()
Finalmente, precisamos definir uma função principal para chamar a função definida acima e definir alguns parâmetros, como palavras-chave, número da página, número do thread, nome do arquivo, etc.:
# 主函数
def main():
# 设置关键词
keyword = "Selenium"
# 设置页数
pages = 10
# 设置线程数
threads = 5
# 设置文件名
file = "results.txt"
# 执行多线程爬虫的主要逻辑
run_crawler(keyword, pages, threads, file)
# 调用主函数
if __name__ == "__main__":
main()
O caso
Executando o código acima, podemos ver os seguintes resultados no arquivo local:
Selenium - Web Browser Automation Selenium - Web Browser Automation (https://www.selenium.dev/)
Selenium Tutorial_w3cschool Selenium Tutorial_w3cschool (https: //www.w3cschool .cn/selenium/)
Selenium_ Baidu Encyclopedia Selenium_ Baidu Encyclopedia (https://baike.baidu.com/item/Selenium/1096491)
Selenium Tutorial - Tutorial para novatos Tutorial de selênio - Tutorial para novatos (https://www.runoob.com/ selenium/selenium-tutorial.html)
Selenium Chinese Community_Selenium Automation Testing_Selenium Tutorial_Selenium … Selenium Chinese Community_Selenium Automation Testing_Selenium Tutorial_Selenium … (http://www.selenium.org.cn/)
Selenium - Wikipedia Selenium - Wikipedia (https://en.wikipedia) .org/wiki/Selenium)
epílogo
Este artigo descreve como usar o Selenium para automatizar os navegadores Firefox para rastreamento distribuído e multithread de conteúdo Javascript. Através de um exemplo simples, mostramos como escrever código na linguagem Python e usar um servidor proxy crawler para ocultar nosso endereço IP real. Também apresentamos algumas vantagens, desvantagens e precauções da tecnologia crawler.Espero que este artigo seja útil para você.