Diretório de artigos
Prefácio
Estou muito feliz em conhecê-lo no nível 16. Neste ponto, você concluiu o aprendizado do conhecimento em todos os níveis, parabéns!
Mas isso não significa que este nível possa ser tratado de ânimo leve, porque ainda temos coisas muito importantes a realizar.
Conduziremos uma revisão geral do conhecimento anterior do rastreador e construiremos uma estrutura de conhecimento. Quando você receber quaisquer requisitos do rastreador posteriormente, poderá estar ciente deles e não entrar em pânico.
Como muitos assuntos, os répteis são suficientes para começar, mas na realidade não há fim para o aprendizado. Portanto, fornecerei a você um guia de rotas para aprendizado avançado - o que mais você pode aprender se quiser continuar a melhorar os rastreadores.
E se houver répteis, naturalmente haverá anti-répteis. Vamos nos concentrar nos métodos anti-répteis disponíveis e nas estratégias disponíveis para lidar com os anti-répteis.
Sempre acreditei que todo assunto terá um núcleo espiritual que se transcende. Seria uma pena se você apenas dominasse as habilidades, mas não conseguisse descobrir a beleza do assunto. Então, no final deste nível, deixei para vocês uma pequena carta para falar sobre o que está por trás deste curso.
Vamos começar agora.
Revisão geral dos rastreadores
Ainda me lembro que tudo começou com este diagrama, que foi usado para descrever como o navegador funcionava:
Solicitações e respostas. Essas duas coisas constituem quase todo o conteúdo de aprendizagem que aprenderemos mais tarde.
No nível 0, quando falamos em crawlers, utilizamos programas para obter dados que nos são úteis na Internet. O que o programa faz, as etapas mais críticas são “solicitação” e “resposta”.
Com base nisso, definimos as “quatro etapas do crawler”: obtenção de dados (incluindo duas ações de solicitação e resposta), análise de dados, extração de dados e armazenamento de dados.
Ao mesmo tempo, também aprendemos o método de solicitação mais simples: requests.get()
import requests
url = ''
response = requests.get(url)
ferramenta
Se você quer fazer bem o seu trabalho, primeiro você deve aprimorar suas ferramentas, precisamos de uma ferramenta com a qual possamos ver todas as solicitações para que possamos completar as quatro etapas do rastreador. Esta ferramenta é chamada Rede.
A rede pode registrar todas as solicitações feitas pelo navegador. Os que usamos mais comumente são: ALL (ver tudo)/XHR (apenas ver XHR)/Doc (Documento, a 0ª solicitação geralmente está aqui).Às vezes também olhamos: Img (apenas ver imagens)/Media (apenas ver Arquivos de mídia)/Outros. Por fim, JS e CSS são códigos front-end, responsáveis por iniciar requisições e implementação de páginas; Font é a fonte do texto; e entender WS e Manifest requer conhecimento de programação de redes. Se você não é especializado nisso, não precisa entende isso.
Eles compõem todo o conteúdo do Elements, que são as páginas coloridas que você costuma ver.
Em rastreadores, geralmente usamos XHR e Doc. Podemos encontrar o código-fonte de uma página da web no Doc, e as informações que não podem ser encontradas no código-fonte da página da web geralmente podem ser encontradas no XHR. Com a sua existência, as pessoas podem carregar novos conteúdos sem ter que atualizar/pular a página web. Hoje, se você aprendeu o conceito de "sincronização/assíncrona", também pode dizer que o XHR nos ajuda a implementar solicitações assíncronas.
Quanto ao local onde os dados estão ocultos, no nível 6 oferecemos uma solução:
Duas flores desabrocham, uma de cada lado.
Análise e Extração (1)
Quando os dados estão ocultos no código-fonte da página da web, temos uma cadeia completa de "rastreador de quatro etapas", aqui a biblioteca mais importante é chamada BeautifulSoup, que pode fornecer um conjunto completo de soluções de análise e extração de dados. O uso é o seguinte:
Podemos escrever código assim:
import requests
# 引用requests库
from bs4 import BeautifulSoup
# 引用BeautifulSoup库
res_foods = requests.get('http://www.xiachufang.com/explore/')
# 获取数据
bs_foods = BeautifulSoup(res_foods.text,'html.parser')
# 解析数据
tag_name = bs_foods.find_all('p',class_='name')
# 查找包含菜名和URL的<p>标签
tag_ingredients = bs_foods.find_all('p',class_='ing ellipsis')
# 查找包含食材的<p>标签
list_all = []
# 创建一个空列表，用于存储信息
for x in range(len(tag_name)):
# 启动一个循环，次数等于菜名的数量
list_food = [tag_name[x].text[18:-15],tag_name[x].find('a')['href'],tag_ingredients[x].text[1:-1]]
# 提取信息，封装为列表
list_all.append(list_food)
# 将信息添加进list_all
print(list_all)
# 打印
# 以下是另外一种解法
list_foods = bs_foods.find_all('div',class_='info pure-u')
# 查找最小父级标签
list_all = []
# 创建一个空列表，用于存储信息
for food in list_foods:
tag_a = food.find('a')
# 提取第0个父级标签中的<a>标签
name = tag_a.text[18:-15]
# 菜名，使用[18:-15]切掉了多余的信息
URL = 'http://www.xiachufang.com'+tag_a['href']
# 获取URL
tag_p = food.find('p',class_='ing ellipsis')
# 提取第0个父级标签中的<p>标签
ingredients = tag_p.text[1:-1]
# 食材，使用[1:-1]切掉了多余的信息
list_all.append([name,URL,ingredients])
# 将菜名、URL、食材，封装为列表，添加进list_all
print(list_all)
# 打印
Aqui, quero enfatizar a questão da codificação: mesmo muitos veteranos em crawlers frequentemente tropeçam na codificação, então não cometa erros também. Quando houver um problema com a decodificação automática de response.text, não hesite em usar response.encoding='' para modificar a codificação você mesmo.
Análise e Extração (2)
Vejamos o outro lado das coisas - quando os dados aparecem no XHR.
O tipo mais importante de dados transmitidos pelo XHR é escrito no formato JSON. Assim como o HTML, esses dados podem armazenar uma grande quantidade de conteúdo de forma organizada. O tipo de dados do json é "texto". Na linguagem Python, chamamos isso de string. Podemos facilmente converter dados no formato json em listas/dicionários e também podemos converter dicionários/listas em dados no formato json.
Como analisar dados JSON? A resposta é a seguinte:
A extração naturalmente não é difícil, afinal foi transformada em lista/dicionário. Você está muito familiarizado com listas/dicionários. Finalmente, você tem esta imagem em mente:
Um pedido mais poderoso
O que é interessante é o pedido em si. Em estudos anteriores, na verdade, há apenas um parâmetro em seu requests.get(), que é o URL.
Mas, na verdade, esta solicitação pode ter vários parâmetros.
params nos permite solicitar dados com parâmetros: Qual página eu quero? Palavras-chave que desejo pesquisar? Quantos dados eu quero?
cabeçalhos, cabeçalhos de solicitação. O que isso diz ao servidor, qual é o meu dispositivo/navegador? De que página eu vim?
Mais tarde, você descobrirá que além da solicitação get, existe outro método de solicitação - post. A diferença entre post e get é que get é um parâmetro de exibição de texto não criptografado e post é um parâmetro de exibição de texto não criptografado. Depois de aprender a postar, você terá mais dois parâmetros disponíveis:
Na pós-solicitação, usamos dados para passar parâmetros, e seu uso é muito semelhante ao de params.
Cookies, o nome chinês é "biscoitos pequenos". Mas não tem nada a ver com “biscoitos”. Sua função é permitir que o servidor “lembre de você”. Por exemplo, geralmente quando você faz login em um site, você verá uma opção marcável “Lembrar de mim” na página de login. Se você clicar na caixa de seleção, o servidor irá gerar um cookie e vinculá-lo à sua conta. Em seguida, ele informa o seu navegador sobre o cookie, permitindo que o navegador armazene o cookie no seu computador local. Na próxima vez que o navegador acessar o blog com cookies, o servidor saberá quem você é, e você poderá acessá-lo diretamente sem precisar digitar novamente sua conta e senha.
Neste ponto, consideremos o caso extremo. Seu código pode ficar assim:
import requests
# 定义url_1，headers和data
url_1 = 'https://…'
headers = {
'user-agent':''}
data = {
}
login_in = requests.post(url,headers=headers,data=data)
cookies = login_in.cookies
# 完成登录，获取cookies
url_2 = 'https://…'
params = {
}
# 定义url和params
response = requests.get(url,headers=headers,params=params,cookies=cookies)
# 带着cookies重新发起请求
armazenar
Obtenha dados de várias maneiras, analise e extraia dados de várias maneiras. o levará à última parada: armazenamento de dados.
Existem muitas maneiras de armazenar dados, sendo as mais comuns: csv e excel.
#csv写入的代码：
import csv
csv_file=open('demo.csv','w',newline='')
writer = csv.writer(csv_file)
writer.writerow(['电影','豆瓣评分'])
csv_file.close()
#csv读取的代码：
import csv
csv_file=open('demo.csv','r',newline='')
reader=csv.reader(csv_file)
for row in reader:
print(row)
#Excel写入的代码：
import openpyxl
wb=openpyxl.Workbook()
sheet=wb.active
sheet.title='new title'
sheet['A1'] = '漫威宇宙'
rows= [['美国队长','钢铁侠','蜘蛛侠','雷神'],['是','漫威','宇宙', '经典','人物']]
for i in rows:
sheet.append(i)
print(rows)
wb.save('Marvel.xlsx')
#Excel读取的代码：
import openpyxl
wb = openpyxl.load_workbook('Marvel.xlsx')
sheet=wb['new title']
sheetname = wb.sheetnames
print(sheetname)
A1_value=sheet['A1'].value
print(A1_value)
Mais rastreadores
Da perspectiva das quatro etapas de um rastreador, existem poucos rastreadores no mundo com os quais você não consegue lidar. Como você pode simular todas as solicitações com código Python, você sabe como analisar todas as respostas. Quando você receber quaisquer requisitos do rastreador posteriormente, poderá estar ciente deles e não entrar em pânico.
Mas e se houver tantos dados para rastrear que o programa ficará lento? Use corrotinas.
Síncrono e assíncrono -
Multi-rotina é um método assíncrono não preemptivo. Ao usar multi-corrotinas, várias tarefas de rastreamento podem ser executadas alternadamente de forma assíncrona.
Abaixo está o código de exemplo:
import gevent,time,requests
from gevent.queue import Queue
from gevent import monkey
monkey.patch_all()
start = time.time()
url_list = ['https://www.baidu.com/',
'https://www.sina.com.cn/',
'http://www.sohu.com/',
'https://www.qq.com/',
'https://www.163.com/',
'http://www.iqiyi.com/',
'https://www.tmall.com/',
'http://www.ifeng.com/']
work = Queue()
for url in url_list:
work.put_nowait(url)
def crawler():
while not work.empty():
url = work.get_nowait()
r = requests.get(url)
print(url,work.qsize(),r.status_code)
tasks_list = [ ]
for x in range(2):
task = gevent.spawn(crawler)
tasks_list.append(task)
gevent.joinall(tasks_list)
end = time.time()
print(end-start)
Rastreador mais poderoso - estrutura
À medida que você escreve mais e mais código do rastreador, uma estrutura completa que resolve todos os problemas do rastreador se tornará cada vez mais atraente para você.
Scrapy aparece diante de seus olhos. A estrutura do Scrapy——
Como funciona o Scrapy——
Como usar o Scrapy——
Adicione asas ao réptil
Além do caminho principal desse rastreador do zero, da existência para muitos, de muitos para fortes. Também aprendemos três ferramentas poderosas: selênio, notificações por e-mail e tempo.
Eles dão asas aos répteis, facilitando a realização de coisas mais interessantes.
Vamos falar primeiro sobre o Selenium. Aprendemos como configurar dois navegadores, o modo visual e o modo silencioso. Ambos têm suas próprias vantagens.
Depois aprendi como usar .get('URL') para obter dados e como analisar e extrair dados.
Neste processo, o processo de conversão do objeto:
Além do método acima, você também pode usar o BeautifulSoup para analisar e extrair dados.A premissa é primeiro obter o código-fonte da página da web em formato de string.
HTML源代码字符串 = driver.page_source
E algumas maneiras de automatizar as operações do navegador.
Quanto ao email, é um processo como este:
Os módulos que queremos utilizar são smtplib e email, o primeiro é responsável pelo processo de conexão ao servidor, login, envio e saída. Este último é responsável pelo preenchimento do título e corpo do email.
O último código de exemplo é assim:
import smtplib
from email.mime.text import MIMEText
from email.header import Header
#引入smtplib、MIMEText和Header
mailhost='smtp.qq.com'
#把qq邮箱的服务器地址赋值到变量mailhost上，地址应为字符串格式
qqmail = smtplib.SMTP()
#实例化一个smtplib模块里的SMTP类的对象，这样就可以调用SMTP对象的方法和属性了
qqmail.connect(mailhost,25)
#连接服务器，第一个参数是服务器地址，第二个参数是SMTP端口号。
#以上，皆为连接服务器。
account = input('请输入你的邮箱：')
#获取邮箱账号，为字符串格式
password = input('请输入你的密码：')
#获取邮箱密码，为字符串格式
qqmail.login(account,password)
#登录邮箱，第一个参数为邮箱账号，第二个参数为邮箱密码
#以上，皆为登录邮箱。
receiver=input('请输入收件人的邮箱：')
#获取收件人的邮箱。
content=input('请输入邮件正文：')
#输入你的邮件正文，为字符串格式
message = MIMEText(content, 'plain', 'utf-8')
#实例化一个MIMEText邮件对象，该对象需要写进三个参数，分别是邮件正文，文本格式和编码
subject = input('请输入你的邮件主题：')
#输入你的邮件主题，为字符串格式
message['Subject'] = Header(subject, 'utf-8')
#在等号的右边是实例化了一个Header邮件头对象，该对象需要写入两个参数，分别是邮件主题和编码，然后赋值给等号左边的变量message['Subject']。
#以上，为填写主题和正文。
try:
qqmail.sendmail(account, receiver, message.as_string())
print ('邮件发送成功')
except:
print ('邮件发送失败')
qqmail.quit()
#以上为发送邮件和退出邮箱。
Vamos falar sobre tempo. Escolhemos o módulo de cronograma. Seu uso é muito simples. O documento oficial descreve assim:
O código abaixo é um exemplo:
import schedule
import time
#引入schedule和time
def job():
print("I'm working...")
#定义一个叫job的函数，函数的功能是打印'I'm working...'
schedule.every(10).minutes.do(job) #部署每10分钟执行一次job()函数的任务
schedule.every().hour.do(job) #部署每×小时执行一次job()函数的任务
schedule.every().day.at("10:30").do(job) #部署在每天的10:30执行job()函数的任务
schedule.every().monday.do(job) #部署每个星期一执行job()函数的任务
schedule.every().wednesday.at("13:15").do(job)#部署每周三的13：15执行函数的任务
while True:
schedule.run_pending()
time.sleep(1)
#15-17都是检查部署的情况，如果任务准备就绪，就开始执行任务。
O texto acima é tudo o que aprendemos na série de níveis do rastreador.
Guia para rota avançada do rastreador
Como dissemos antes, uma introdução básica ao aprendizado dos répteis é suficiente, mas, na realidade, o aprendizado não tem fim. A seguir, falaremos sobre o que mais você pode aprender se quiser continuar aprendendo sobre crawlers em profundidade.
De acordo com nosso roteiro de aprendizagem do rastreador, o guia avançado também está dividido nestas seções: análise e extração, armazenamento, análise e visualização de dados (novo), mais rastreadores, estruturas e outros.
Para obter esse conhecimento, você já pode dominar muitos métodos simples de usá-los, estudando você mesmo os documentos oficiais. Para alguns conhecimentos complexos, especialmente conhecimentos que requerem treinamento em projetos, você pode achar difícil aprendê-los. Esta parte será resolvida e compartilhada com você quando eu fizer minha própria pesquisa no futuro.
Analisar e extrair
Quando dizemos que precisamos aprender análise e extração, queremos dizer aprender análise de bibliotecas. Além da análise do BeautifulSoup e da própria biblioteca de análise do Selenium usada em nossos níveis, também haverá: xpath/lxml, etc. Eles podem ter sintaxe diferente, mas os princípios subjacentes são os mesmos. Você pode facilmente começar e usá-los em alguns cenários adequados.
Se a biblioteca de análise acima tiver pouco impacto, quer você a aprenda ou não, então eu recomendo solenemente que você aprenda expressões regulares (remódulo). As expressões regulares são poderosas: elas permitem que você mesmo defina um conjunto complexo de regras e encontre conteúdo relevante que atenda às condições do texto de destino. Por exemplo, quando estivermos no nível 6, rastrearemos a letra de uma música e o texto que obtivermos será preenchido com vários símbolos.
Com base no conhecimento que aprendemos antes, só podemos cortá-lo repetidas vezes e incansavelmente. Mas usando regras regulares, esse problema pode ser facilmente resolvido.
armazenar
Quando se trata de armazenamento, o conhecimento que temos atualmente é csv e excel. Não são módulos muito difíceis e recomendo que você leia a documentação oficial para saber mais sobre seu uso. Desta forma, também será útil para o trabalho diário automatizado de escritório.
Mas quando a quantidade de dados se torna muito grande (isso não é novidade no mundo dos rastreadores) e o relacionamento entre os dados, deve ser difícil usar uma tabela plana bidimensional simples para transportá-los. Bem, você precisa da ajuda de um banco de dados.
Recomendo que você comece a aprender com as duas bibliotecas MySQL e MongoDB, uma delas é um representante típico de um banco de dados relacional e a outra é um representante típico de um banco de dados não relacional.
Claro, você pode estar curioso sobre o que é um banco de dados relacional e o que é um banco de dados não relacional. Simplificando, projetei duas tabelas, uma para armazenar as informações da conta (apelido, avatar, etc.) dos usuários da Programação Fengbian e outra para armazenar os registros de aprendizagem dos usuários. As duas tabelas estão relacionadas por meio de IDs de usuário exclusivos. Este é um banco de dados relacional. Sem esse recurso, é naturalmente um banco de dados não relacional.
Aprender bancos de dados exige que você seja exposto a outra linguagem: SQL. Mas não é difícil aprender, vamos lá!
Análise e visualização de dados
Ter grandes quantidades de dados tem um significado muito limitado. Os dados devem ser analisados para criar um valor mais profundo. Por exemplo: não é muito significativo obter os endereços e dados de receita das lojas McDonald's na China, mas se a estratégia ideal dos restaurantes de fast food puder ser resumida a partir deles, ela poderá orientar as decisões de negócios.
Ao olhar para Ctrip.com, todas as avaliações de usuários de Shenzhen Happy Valley são de pouca importância. Mas seria muito interessante analisar e resumir o que realmente importa aos usuários quando jogam.
A habilidade aqui é chamada de análise de dados. É a visualização para transmitir as conclusões da análise de dados de forma intuitiva e poderosa.
Sério, esta não é uma habilidade muito simples. A análise de dados de aprendizagem leva mais tempo do que o rastreamento. Então, no futuro, com certeza farei alguns níveis nesta área para ajudar todos a dominá-la.
Se você quiser aprender sozinho, aqui estão os módulos e bibliotecas que recomendo: Pandas/Matplotlib/Numpy/Scikit-Learn/Scipy.
Mais rastreadores
Quando você tem muitos dados para rastrear, você começa a se preocupar com a velocidade do rastreador. Aqui, apresentamos uma ferramenta que permite que vários rastreadores trabalhem juntos – corrotinas.
A rigor, isso não funciona ao mesmo tempo, mas o computador alterna rapidamente entre várias tarefas, fazendo parecer que os rastreadores estão trabalhando ao mesmo tempo.
Portanto, essa forma de trabalhar apresenta um gargalo na otimização da velocidade. Então, o que mais você pode fazer se ainda quiser fazer um avanço?
Já sabemos que as corrotinas usam essencialmente apenas um núcleo da CPU. O rastreador multiprocesso (biblioteca multiprocessamento) permite usar vários núcleos da CPU, para que você possa usar vários processos ou uma combinação de vários processos e várias corrotinas para otimizar ainda mais o rastreador.
Teoricamente, desde que a CPU permita, quantos processos são abertos podem aumentar a velocidade do seu rastreador.
E se a CPU não permitir? Por exemplo, meu computador possui apenas 8 núcleos. E quero romper 8 processos, o que devo fazer?
Resposta, rastreador distribuído. O que isso significa? Os rastreadores distribuídos permitem que vários dispositivos executem o mesmo projeto.
Vamos criar uma fila compartilhada, preenchida com tarefas do crawler a serem executadas. Permita que vários dispositivos obtenham tarefas desta fila compartilhada e concluam a execução. Este é um rastreador distribuído.
Dessa forma, não há mais gargalos limitando seu rastreador – basta adicionar mais dispositivos. Na empresa, diante de um grande número de tarefas do rastreador, eles também usam uma abordagem distribuída para realizar operações do rastreador.
Para implementar um rastreador distribuído, você precisa do conteúdo do próximo bloco - a estrutura.
Rastreador mais poderoso - estrutura
No momento, aprendemos brevemente os princípios básicos e o uso da estrutura Scrapy. E alguns usos mais aprofundados: usar Scrapy para simular login, armazenar bancos de dados, usar proxy HTTP, crawlers distribuídos... estes ainda não foram abordados.
Mas a boa notícia é que a maior parte desse conhecimento está facilmente acessível para você hoje. Porque você dominou a lógica subjacente e o resto são apenas algumas questões gramaticais.
Eu recomendo que você aprenda mais sobre a estrutura Scrapy primeiro. Então conheça alguns outros frameworks excelentes, como: PySpider.
treinamento de projeto
Agora, quando você acessa alguns sites de recrutamento e navega pelas palavras “engenheiro de répteis”, a descrição do trabalho não contém mais palavras que o tornarão desconhecido.
Você começa a sentir que talvez se agregar algum conhecimento e estudo, poderá ser competente. Então, o que está faltando no meio?
Os módulos/bibliotecas/frameworks mencionados acima não são tão importantes porque são ferramentas fáceis de dominar. O mais importante para um engenheiro rastreador é pensar para atingir o objetivo.
Acredito que você já pode sentir que em todos os nossos níveis baseados em projetos, estas três etapas principais são seguidas: confirmação do objetivo, processo de análise e implementação de código (para projetos complexos, o encapsulamento de código também é necessário).
Entre eles, o mais difícil não é a implementação ou encapsulamento de código, mas: confirmar um objetivo razoável, analisar como atingir esse objetivo e projetar como combinar e aplicar esses módulos de ferramentas.
As quatro etapas do rastreador que aprendemos: obter dados, analisar dados, extrair dados e armazenar dados, todas atendem à etapa do "processo de análise".
Onde estão os dados que desejo? Como obter os dados? Como obter dados mais rapidamente? Como armazenar melhor os dados... tudo isso pertence a "pensar para atingir metas".
Adquirir esse tipo de pensamento requer muita prática prática de projeto.
Então, eu gostaria de recomendar a você: conclua todos os exercícios de projeto que forneço; leia mais blogs e páginas iniciais do github casos de aprendizagem de programadores seniores; ao mesmo tempo, explore operações de projeto mais práticas para enriquecer sua experiência com o rastreador.
No futuro, se eu desenvolver um curso de crawler mais avançado para ensinar conhecimentos sobre regularidade, processo, distribuição, etc., com certeza colocarei um grande número de implementações de projetos na linha principal.
Resumo das estratégias de resposta anti-rastreador
Depois de falar sobre o guia de rotas avançado, vamos falar sobre os anti-crawlers. Quase todo o pessoal técnico tem um consenso sobre os anti-rastreadores: os chamados anti-rastreadores nunca pretendem eliminar completamente os rastreadores; em vez disso, estão a tentar encontrar formas de limitar o número de visitas dos rastreadores a um intervalo aceitável e não deixá-los ser muito inescrupuloso.
O motivo é simples: até o final da escrita do código do crawler, ele não é diferente de uma pessoa real acessando a Internet. O lado do servidor não tem como saber se é um humano ou um rastreador. Se você quiser banir completamente os rastreadores, os usuários normais também não conseguirão acessar. Portanto, só podemos encontrar formas de restringir, não de proibir.
Portanto, podemos entender quais técnicas de “anti-crawler” estão disponíveis e então pensar em como lidar com o “anti-crawler”.
Alguns sites limitarão os cabeçalhos de solicitação, ou seja, cabeçalhos de solicitação, por isso temos que preencher user-agent para declarar nossa identidade, e às vezes também temos que preencher origin e referer para declarar a origem da solicitação.
Alguns sites restringirão o login e você não poderá acessá-los a menos que faça login. Em seguida utilizaremos o conhecimento de cookies e sessões para simular o login.
Alguns sites realizarão algumas interações complexas, como definir “códigos de verificação” para bloquear o login. Isso é mais difícil de fazer. Geralmente há duas soluções: usamos Selenium para inserir manualmente o código de verificação; usamos algumas bibliotecas de processamento de imagem para identificar automaticamente o código de verificação (tesserocr/pytesserart/pillow).
Alguns sites imporão restrições de IP. O que isso significa? Quando costumamos ficar online, sempre carregamos um endereço IP. Um endereço IP é como um número de telefone: com o número de telefone de alguém, você pode falar com essa pessoa. Da mesma forma, com o endereço IP de um dispositivo, você pode se comunicar com esse dispositivo.
Use um mecanismo de busca para pesquisar “IP” e você também poderá ver seu endereço IP.
Como acima, mostra um determinado endereço IP e o provedor de serviços de comunicação de rede usado é a Shenzhen Telecom. Se este endereço IP rastrear o site com muita frequência, o servidor bloqueará temporariamente as solicitações deste endereço IP.
Existem duas soluções: use time.sleep() para limitar a velocidade do rastreador; estabeleça um pool de proxy IP (você pode procurar por proxies IP disponíveis na Internet) e use outro IP se não puder ser usado. A sintaxe aproximada é esta:
import requests
url = 'https://…'
proxies = {
'http':'http://…'}
# ip地址
response = requests.get(url,proxies=proxies)
Acima estão as estratégias anti-crawler mais comuns no mercado e as contramedidas correspondentes. Você descobrirá que nada pode realmente impedi-lo. Isto apenas confirma a frase: os chamados anti-crawlers nunca eliminam completamente os crawlers; em vez disso, encontram formas de limitar o número de visitas dos crawlers a um intervalo aceitável e não os deixam ser demasiado inescrupulosos.
As últimas palavras escritas
Sempre acreditei que cada sujeito tem seu temperamento único e isso tem um impacto profundo nas pessoas. Se você quer educar, simplesmente ensinar o conhecimento de forma completa não é suficiente; você precisa expressar esse tipo de coisa.
Os antigos diziam que “pregar” em “pregar, transmitir conhecimento e tirar dúvidas” é falar desse tipo de coisa.
Então, o que há de diferente no Reptile?
Consultei muitas pessoas seniores ao meu redor que são muito boas em escrever rastreadores: Como você costuma escrever rastreadores? Qual é a coisa mais importante ao escrever um rastreador?
Eles deram muitas explicações diferentes, mas todos apontaram para a mesma resposta:
Confirme o objetivo - analise o processo - primeiro implemente o código linha por linha para o processo - encapsulamento do código.
Aqui o mais importante é confirmar o objetivo, e o mais difícil é o processo de análise. Escrever código é apenas uma coisa natural.
Neste processo você encontrará muitas dificuldades. Mas não importa, se tiver dificuldades é só estudar e conferir a documentação, você sempre encontra uma solução.
No mundo da programação quase nada é impossível.
Foi depois de ouvir as respostas deles que projetei o nível como está agora: confirmação de objetivos - processo de análise - implementação de código (e às vezes encapsulamento de código) em todos os lugares.
Neste processo, encontraremos dificuldades. Então, vamos aprender novos conhecimentos e verificar documentos. Sempre que encontramos novo conhecimento, precisamos entender o que é, como usá-lo e utilizá-lo na prática.
Para que todos possam concluir melhor o "processo de análise" mais difícil, propusemos quatro etapas para os rastreadores: obtenção de dados - análise de dados - extração de dados - armazenamento de dados.
Acho que é isso que esses 16 níveis do rastreador esperam expressar: não há meta que você não possa alcançar com muito trabalho e sabedoria, e não há dificuldade que você não possa superar com muito trabalho e sabedoria.
Quando você encontra montanhas e rios, você constrói estradas e pontes. Pessoas que não estão dispostas a passar a vida na mediocridade têm sonhos, e sonhos são objetivos.
O objetivo pode ser analisado e o processo pode ser realizado.
Neste processo, você pode encontrar dificuldades. Não importa, existem soluções para todos os problemas.
Faça estradas ao encontrar montanhas e construa pontes ao encontrar água.
Talvez você pense que estou falando de canja de galinha. Não, estou falando de teoria, estou falando de experiências que aconteceram com você.
Falando em teoria, nos últimos anos, além de tecnologia, estive imerso em um assunto chamado “psicologia cognitiva”. O que estuda é o processo cognitivo humano. É muito interessante ler.
Neste livro, o capítulo que mais me impressionou chama-se “Resolução de Problemas”, que discute como as pessoas resolvem problemas. Finalmente, uma conclusão importante é que a maneira mais eficaz de os humanos resolverem problemas é a “análise de objetivos-meios”.
Confirme o objetivo, divida-o camada por camada, transforme o grande problema em um conjunto de pequenos problemas, cada pequeno problema tem um meio para alcançá-lo, e então é só fazer. As coisas parecem ser tão simples.
Mas as coisas não são tão simples.
Não sei se você ainda se lembra de como é o nível 5. Naquela época, você tinha acabado de aprender BeautifulSoup e recebeu um pedido: rastreie as informações das músicas de Jay Chou.
Você identifica os objetivos – analisa o processo – e então codifica a implementação. De repente, o resultado foi inesperado – os dados desejados não foram obtidos.
Você não sente pânico com isso, por quê?
Porque cada etapa do nosso processo deriva de um raciocínio muito claro. Podemos localizar facilmente o problema - basta voltar passo a passo.
A extração está errada? Verifique, não. A análise está errada? Verifique, não. Essa deve ser a maneira errada de obter os dados. Vamos reanalisar o processo: aprender novos conhecimentos - XHR, verificar documentos - analisar dados json.
Da mesma forma, quando o que fazemos não sai como esperado, podemos verificar se foi executado de forma errada? Não, esse é o método errado? Caso contrário, você precisa pensar se há algum problema com o estabelecimento de metas.
Continue pensando assim e acredito que tudo na sua vida pode ser claro e alcançável. Mesmo que algo dê errado, a origem pode ser claramente rastreada.
Você abre caminho através de montanhas e rios e nunca entra em pânico. Isso é tudo que quero lhe dizer.
vamos! Você eventualmente se tornará o grande deus dos seus sonhos!