目录
- 爬虫
- 1 爬虫简介
- 2 爬虫的流程
- 3 requests模块
- 4 beautifulsoup4模块
- 5 代理池搭建
- 6 验证码破解之打码平台
- 7 爬拉勾网职位信息
- 8 爬《三国演义》
- 9 爬肯德基门店
- 10 爬糗事百科段子
- 11 selenium使用
- 12 爬取京东商品信息
- 13 自动登录12306
- 14 cookie池
- 15 抓包工具介绍
- 16 scrapy
- 17 爬取抽屉新闻
- 18 自动点赞
- 19 爬取cnblogs全站
- 20 scrapy的请求传参
- 21 提升scrapy爬取数据效率
- 22 scrapy的中间件
- 23 在scrapy中的使用selenium
- 24 去重规则源码分析
- 25 分布式爬虫(scrapy-redis)
- 26 破解知乎登陆(js逆向和解密)
- 27 爬虫的反爬措施总结
- 拓展
爬虫
1 爬虫简介
爬虫就是通过代码模拟人，向浏览器发送请求(使用模块：requests，selenium)，
获取到网页前端代码后通过筛选，提取出有用的数据(使用模块：bs4，xpath，re)
最后将数据存放于数据库或文件中(文件，excel，mysql，redis，mongodb)
爬虫协议
robots.txt (写了允许爬的路由)
如：https://www.cnblogs.com/robots.txt
2 爬虫的流程
# 1、发起请求
使用http库向目标站点发起请求，即发送一个Request
Request包含：请求头、请求体、请求地址(浏览器调试，抓包工具)，请求头(难)，请求体(难)，请求方法
# 2、获取响应内容
如果服务器能正常响应，则会得到一个Response
Response包含：html，xml，json，图片，视频，经过加密的未知格式(需要解密)等
# 3、解析内容
解析html数据：正则表达式，第三方解析库如Beautifulsoup，pyquery等
解析json数据：json模块
解析二进制数据:以b的方式写入文件
# 4、保存数据
数据库：推荐使用Mongodb(存json格式数据)
文件
# 5、提高效率
开启多进程，多线程，协程
3 requests模块
安装：pip3 install requests
3.1 requests模块简介
# 介绍：
使用requests可以模拟浏览器的请求，比起urllib，requests模块的api更加便捷(本质就是封装了urllib3)
# 注意点：
requests库发送请求将网页内容下载下来以后，并不会执行js代码，
需要分析目标站点然后手动发起新的request请求
# 各种请求方式：常用的是get和post
import requests
r = requests.get('https://api.github.com/events')
r = requests.post('http://httpbin.org/post', data = {'key':'value'})
r = requests.put('http://httpbin.org/put', data = {'key':'value'})
r = requests.delete('http://httpbin.org/delete')
r = requests.head('http://httpbin.org/get')
r = requests.options('http://httpbin.org/get')
# 建议在正式学习requests前，先熟悉下HTTP协议
http://www.cnblogs.com/linhaifeng/p/6266327.html
3.2 requests的使用
3.2.1 基本请求
import requests
response=requests.get('http://dig.chouti.com/')
print(response.text)
3.2.2 带参数的请求
3.2.2.1 带请求头参数的方法
# 对百度发请求，携带查询参数:wd=python
# 在请求头内将自己伪装成浏览器，使用浏览器的User-Agent，该参数能显示请求的来源，否则百度不会正常返回页面内容，即在请求头内添加User-Agent
'User-Agent':'Mozilla/5.0 ...'
import requests
response=requests.get('https://www.baidu.com/s?wd=python',headers={'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36'})
print(response.text)
# 请求头中较重要的参数
Host
Referer # 大型网站通常都会根据该参数判断请求的来源(一般检查是否为本站)
User-Agent # 客户端(请求来源的客户端)
Cookie
3.2.2.2 第一种带查询参数的方法(不推荐)
# 第一种带参数的方法:直接在url地址后使用?&=进行拼接，如?name=aaa&age=18
# 使用第一种如果查询关键词中有中文或者有其他特殊符号，可能会报错，所以需要将中文进行url编码
from urllib.parse import urlencode,unquote
# urlencode编码，unquote解码
print(urlencode({'wd':'哈哈哈'}))
# wd=%E5%93%88%E5%93%88%E5%93%88
print(unquote('wd=%E5%93%88%E5%93%88%E5%93%88'))
# wd=哈哈哈
import requests
header={'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36'}
res=requests.get('https://www.baidu.com/s?wd=%E5%93%88%E5%93%88%E5%93%88',headers=header)
3.2.2.3 第二种带查询参数的方法(推荐)
import requests
header={'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36'}
res=requests.get('https://www.baidu.com/s',headers=header,params={'wd':'哈哈哈'})
# 使用params参数，传入字典即可，自动转换为url编码，无需手动转换
3.2.2.4 手动带cookie参数的两种方法
# 登录github，然后从浏览器中获取cookies，就可以直接使用cookie登录了，无需输入用户名密码
# 用户名:egonlin 邮箱378533872@qq.com 密码lhf@123
import requests
# 第一次请求 登录
res=session.post('https://github.com/session',data={"username":"wu",'password':'123'})
# 取出cookie信息
Cookies={'user_session':'wGMHFJKgDcmRIVvcA14_Wrt_3xaUyJNsBnPbYzEL6L0bHcfc'}
# 下次发送请求时手动携带，传入cookies，cookies是一个字典或者CookieJar对象
response=requests.get('https://github.com/settings/emails',cookies=Cookies)
# 也可以手动写入headers中
response=requests.get('https://github.com/settings/emails',headers={"Cookie":Cookies})
# github对请求头没有限制，无需定制user-agent，对于其他网站可能需要定制
print('378533872@qq.com' in response.text) #True
3.2.2.5 自动带cookie参数的方法
import requests
session=requests.session()
# 第一次请求 登录
res=session.post('https://github.com/session',data={"username":"wu",'password':'123'})
# cookie信息会自动存入res，下次发送请求自动携带cookie信息
res2=session.get('https://github.com/settings/emails')
3.2.2.6 带请求体的方法
# 携带数据：urlencoded
res=requests.post('http://127.0.0.1:8000/index/',data={'name':'wu'})
print(res.text)
# 携带数据：json
res=requests.post('http://127.0.0.1:8000/index/',json={'age':1,},)
print(res.text)
3.2.3 请求对象的属性
res=requests.post('http://127.0.0.1:8000/index/',data={'name':'wu'})
print(respone.text) # 响应的文本
print(respone.content) # 响应体的二进制
print(respone.status_code) # 响应状态码
print(respone.headers) # 响应头
print(respone.cookies) # cookie
print(respone.cookies.get_dict()) # 把cookie转成字典
print(respone.cookies.items()) # [(k1，v1),(k2,v2),(k3,v3)]
print(respone.url) # 请求的url
print(respone.history) # []内为重定向之前的历史记录响应对象
print(respone.encoding) # 响应的编码方式
print(respone.iter_content()) # 视频，大文件，可以循环取出来
for line in respone.iter_content():
f.write(line)
3.2.4 页面乱码
# 页面乱码问题解决方案
res=requests.get('http://www.autohome.com/news')
# 方式一：指定解码方式
res.encoding='gb2312'
# 方式二：自动解码
res.encoding=res.apparent_encoding
3.2.5 解析json格式
import json
respone=requests.post('http://127.0.0.1:8000/index/',data={'name':'lqz'})
print(type(respone.text)) # 响应的文本
# 手动序列化
print(json.loads(respone.text))
# 内置的序列化方法
print(respone.json()) # 相当于上面那句话
3.2.6 ssl(了解)
import requests
# 对于需要证书的网址，直接访问会报警告,返回200
respone=requests.get('https://www.12306.cn')
print(respone.status_code)
# 使用证书，需要手动携带
import requests
respone=requests.get('https://www.12306.cn',cert=('/path/server.crt','/path/key'))
print(respone.status_code)
3.2.7 代理
import requests
respone=requests.get('http://127.0.0.1:8000/index/',proxies={'http':'代理的地址和端口号',})
# 代理池：列表放了若干代理ip，每次随机取一个
# 高匿代理与透明代理：如果使用高匿代理，后端一般无法获取你的ip，使用透明代理，后端能够直接获取到你的ip
# 后端如何拿到透明代理的ip： 后端：X-Forwarded-For
respone=requests.get('https://www.baidu.com/',proxies={'http':'27.46.20.226:8888'})
print(respone.text)
3.2.8 设置超时时间
import requests
respone=requests.get('https://www.baidu.com',timeout=0.0001)
3.2.9 认证设置(了解)
import requests
r=requests.get('xxx',auth=('user','password'))
# 网页弹出登录框，现在已经基本绝迹
print(r.status_code)
3.2.10 异常处理
import requests
from requests.exceptions import *
#可以查看requests.exceptions获取异常类型
try:
r=requests.get('http://www.baidu.com',timeout=0.00001)
except Exception as e:
print(e)
3.2.11 上传文件
import requests
res=requests.post('http://127.0.0.1:8000/index/',files={'myfile':open('a.jpg','rb')})
# files传字典，value为文件对象
print(res.text)
3.3 模拟登陆某网站
# http://www.aa7a.cn/
import requests
session=requests.session()
data = {
'username': '616564099@qq.com',
'password': 'lqz123',
'captcha': 'xxxx', # 验证码
'remember': 1, # 是否记住密码
'ref': 'http://www.aa7a.cn/user.php?act=logout', # referer
'act': 'act_login', # 操作
}
rest = session.post('http://www.aa7a.cn/user.php',data=data)
print(rest.text)
# 拿到cookie
cookie=rest.cookies
print(cookie)
# 携带着cookies，表示登录了，页面中会有我们的用户信息616564099@qq.com
rest1=session.get('http://www.aa7a.cn/index.php')
# rest1=requests.get('http://www.aa7a.cn/index.php')
print('616564099@qq.com' in rest1.text)
3.4 爬取梨视频
# https://www.pearvideo.com/
import requests
import re
res=requests.get('https://www.pearvideo.com/category_loading.jsp?reqType=5&categoryId=1&start=0')
re_video='<a href="(.*?)" class="vervideo-lilink actplay">'
video_urls=re.findall(re_video,res.text)
for video in video_urls:
url='https://www.pearvideo.com/'+video
print(url)
# 向视频详情发送get请求
res_video=requests.get(url)
# print(res_video.text)
re_video_mp4='hdUrl="",sdUrl="",ldUrl="",srcUrl="(.*?)",vdoUrl=srcUrl,skinRes'
video_url=re.findall(re_video_mp4,res_video.text)[0]
print(video_url)
video_name=video_url.rsplit('/',1)[-1]
print(video_name)
res_video_content=requests.get(video_url)
with open(video_name,'wb') as f:
for line in res_video_content.iter_content():
f.write(line)
4 beautifulsoup4模块
Beautiful Soup 是一个可以从HTML或XML文件中提取数据的Python库.它能够通过你喜欢的转换器实现惯用的文档导航,查找,修改文档的方式.Beautiful Soup会帮你节省数小时甚至数天的工作时间.你可能在寻找 Beautiful Soup3 的文档,Beautiful Soup 3 目前已经停止开发,官网推荐在现在的项目中使用Beautiful Soup 4, 移植到BS4
pip3 install beautifulsoup4
用于解析/修改html和xml
#安装 Beautiful Soup
pip install beautifulsoup4
#安装解析器
Beautiful Soup支持Python标准库中的HTML解析器,还支持一些第三方的解析器,其中一个是 lxml .根据操作系统不同,可以选择下列方法来安装lxml:
$ apt-get install Python-lxml
$ easy_install lxml
$ pip install lxml
另一个可供选择的解析器是纯Python实现的 html5lib , html5lib的解析方式与浏览器相同,可以选择下列方法来安装html5lib:
$ apt-get install Python-html5lib
$ easy_install html5lib
$ pip install html5lib
| 解析器 | 使用方法 | 优势 | 劣势 |
|---|---|---|---|
| Python标准库 | BeautifulSoup(markup, "html.parser") |
Python的内置标准库执行速度适中文档容错能力强 | Python 2.7.3 or 3.2.2)前 的版本中文档容错能力差 |
| lxml HTML 解析器 | BeautifulSoup(markup, "lxml") |
速度快文档容错能力强 | 需要安装C语言库 |
| lxml XML 解析器 | BeautifulSoup(markup, ["lxml", "xml"])``BeautifulSoup(markup, "xml") |
速度快唯一支持XML的解析器 | 需要安装C语言库 |
| html5lib | BeautifulSoup(markup, "html5lib") |
最好的容错性以浏览器的方式解析文档生成HTML5格式的文档 | 速度慢不依赖外部扩展 |
4.1 爬取汽车之家新闻
import requests
from bs4 import BeautifulSoup
res=requests.get('https://www.autohome.com.cn/news/1/#liststart')
# print(res.text)
# 第二个参数是解析器类型
# html.parser是python内置的，不需要安装
soup=BeautifulSoup(res.text,'html.parser')
# 安装lxml解析器：pip3 install lxml
soup=BeautifulSoup(res.text,'lxml')
# 查找class为article-wrapper的div
div=soup.find(class_='article-wrapper')
div=soup.find(id='auto-channel-lazyload-article')
print(div)
ul=soup.find(class_='article')
print(ul)
# 继续找ul下的s所有li
li_list=ul.find_all(name='li')
print(len(li_list))
for li in li_list:
# 找li中的内容
title=li.find(name='h3')
if title:
title=title.text
# url=li.find('a')['href']
url='https:'+li.find('a').attrs.get('href')
desc=li.find('p').text
img='https:'+li.find(name='img').get('src')
print('''
新闻标题：%s
新闻地址：%s
新闻摘要：%s
新闻图片：%s
'''%(title,url,desc,img))
4.2 bs4的使用
4.2.1 基本使用演示
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title"><b>The Dormouse's story</b></p>
<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>
<p class="story">...</p>
"""
#基本使用：容错处理,文档的容错能力指的是在html代码不完整的情况下,使用该模块可以识别该错误。使用BeautifulSoup解析上述代码,能够得到一个 BeautifulSoup 的对象,并能按照标准的缩进格式的结构输出
from bs4 import BeautifulSoup
soup=BeautifulSoup(html_doc,'lxml') #具有容错功能
res=soup.prettify() #处理好缩进，结构化显示
print(res)
4.2.2 遍历文档树
#遍历文档树：即直接通过标签名字选择，特点是选择速度快，但如果存在多个相同的标签则只返回第一个
#1、用法
#2、获取标签的名称
#3、获取标签的属性
#4、获取标签的内容
#5、嵌套选择
#6、子节点、子孙节点
#7、父节点、祖先节点
#8、兄弟节点
#遍历文档树：即直接通过标签名字选择，特点是选择速度快，但如果存在多个相同的标签则只返回第一个
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p id="my p" class="title"><b id="bbb" class="boldest">The Dormouse's story</b></p>
<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>
<p class="story">...</p>
"""
#1、用法
from bs4 import BeautifulSoup
soup=BeautifulSoup(html_doc,'lxml')
# soup=BeautifulSoup(open('a.html'),'lxml')
print(soup.p) #存在多个相同的标签则只返回第一个
print(soup.a) #存在多个相同的标签则只返回第一个
#2、获取标签的名称
print(soup.p.name)
#3、获取标签的属性
print(soup.p.attrs)
p=soup.body.p
# class可能有多个，即便有一个也放到列表中
print(p.attrs)
print(p.attrs.get('class'))
print(p['class'])
print(p.get('class'))
#4、获取标签的内容
print(soup.p.string) # p下的文本只有一个时，取到，否则为None
print(soup.p.strings) # 拿到一个生成器对象, 取到p下所有的文本内容
print(soup.p.text) # 取到p下所有的文本内容
for line in soup.stripped_strings: # 去掉空白
print(line)
'''
如果tag包含了多个子节点,tag就无法确定 .string 方法应该调用哪个子节点的内容, .string 的输出结果是 None，如果只有一个子节点那么就输出该子节点的文本，比如下面的这种结构，soup.p.string 返回为None,但soup.p.strings就可以找到所有文本
<p id='list-1'>
哈哈哈哈
<a class='sss'>
<span>
<h1>aaaa</h1>
</span>
</a>
<b>bbbbb</b>
</p>
'''
# 5、嵌套选择
print(soup.head.title.string)
print(soup.body.a.string)
# 6、子节点、子孙节点
print(soup.p.contents) # p下所有子节点
print(soup.p.children) # 得到一个迭代器,包含p下所有子节点
for i,child in enumerate(soup.p.children):
print(i,child)
print(soup.p.descendants) # 获取子孙节点,p下所有的标签都会选择出来
for i,child in enumerate(soup.p.descendants):
print(i,child)
# 7、父节点、祖先节点
print(soup.a.parent) # 获取a标签的父节点
print(soup.a.parents) # 找到a标签所有的祖先节点，父亲的父亲，父亲的父亲的父亲...
# 8、兄弟节点
print('=====>')
print(soup.a.next_sibling) # 下一个兄弟
print(soup.a.previous_sibling) # 上一个兄弟
print(list(soup.a.next_siblings)) # 下面的兄弟们=>生成器对象
print(soup.a.previous_siblings) # 上面的兄弟们=>生成器对象
4.2.3 搜索文档树
4.2.3.1 过滤器
搜索文档树：BeautifulSoup定义了很多搜索方法,这里着重介绍2个: find() 和 find_all() .其它方法的参数和用法类似
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p id="my p" class="title"><b id="bbb" class="boldest">The Dormouse's story</b>
</p>
<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>
<p class="story">...</p>
"""
from bs4 import BeautifulSoup
soup=BeautifulSoup(html_doc,'lxml')
#五种过滤器: 字符串、正则表达式、列表、bool、方法
# 字符串：即标签名
print(soup.find_all('b'))
print(soup.find(href='http://example.com/elsie'))
print(soup.find(attrs={'id':'my_p'}))
# 正则表达式
import re
print(soup.find_all(re.compile('^b'))) #找出b开头的标签，结果有body和b标签
# 列表：如果传入列表参数,Beautiful Soup会将与列表中任一元素匹配的内容返回.下面代码找到文档中所有<a>标签和<b>标签:
print(soup.find_all(['a','b']))
print(soup.find_all(class_=['sister','title']))
# bool：可以匹配任何值,下面代码查找到所有的tag,但是不会返回字符串节点
print(soup.find_all(id=False))
print(soup.find_all(href=True))
# 方法(了解):如果没有合适过滤器,那么还可以定义一个方法,方法只接受一个元素参数 ,如果这个方法返回 True 表示当前元素匹配并且被找到,如果不是则反回 False
def has_class_but_no_id(tag):
return tag.has_attr('class') and not tag.has_attr('id')
print(soup.find_all(has_class_but_no_id))
# bs4的修改文档树 软件配置文件是xml格式的
# 软件的配置文件
# ini：configparser
# conf
# xml：bs4
# yaml格式
4.2.3.2 find_all
# find_all( name , attrs , recursive , text , **kwargs )
# name: 搜索name参数的值可以使任一类型的 过滤器 ,字符窜,正则表达式,列表,方法或是 True .
print(soup.find_all(name=re.compile('^t')))
# keyword: key=value的形式，value可以是过滤器：字符串 , 正则表达式 , 列表, True .
print(soup.find_all(id=re.compile('my')))
print(soup.find_all(href=re.compile('lacie'),id=re.compile('d'))) #注意类要用class_
print(soup.find_all(id=True)) #查找有id属性的标签
# 有些tag属性在搜索不能使用,比如HTML5中的 data-* 属性:
data_soup = BeautifulSoup('<div data-foo="value">foo!</div>','lxml')
# data_soup.find_all(data-foo="value") #报错：SyntaxError: keyword can't be an expression
# 但是可以通过 find_all() 方法的 attrs 参数定义一个字典参数来搜索包含特殊属性的tag:
print(data_soup.find_all(attrs={"data-foo": "value"}))
# [<div data-foo="value">foo!</div>]
# 按照类名查找，注意关键字是class_，class_=value,value可以是五种选择器之一
print(soup.find_all('a',class_='sister')) #查找类为sister的a标签
print(soup.find_all('a',class_='sister ssss')) #查找类为sister和sss的a标签，顺序错误也匹配不成功
print(soup.find_all(class_=re.compile('^sis'))) #查找类为sister的所有标签
# attrs
print(soup.find_all('p',attrs={'class':'story'}))
# text: 值可以是：字符，列表，True，正则
print(soup.find_all(text='Elsie'))
print(soup.find_all('a',text='Elsie'))
# limit参数:如果文档树很大那么搜索会很慢.如果我们不需要全部结果,可以使用 limit 参数限制返回结果的数量.效果与SQL中的limit关键字类似,当搜索到的结果数量达到 limit 的限制时,就停止搜索返回结果
print(soup.find_all('a',limit=2))
# recursive:调用tag的 find_all() 方法时,Beautiful Soup会检索当前tag的所有子孙节点,如果只想搜索tag的直接子节点,可以使用参数 recursive=False.即只查找第一层
print(soup.html.find_all('a'))
print(soup.html.find_all('a',recursive=False))
'''
像调用 find_all() 一样调用tag
find_all() 几乎是Beautiful Soup中最常用的搜索方法,所以我们定义了它的简写方法. BeautifulSoup 对象和 tag 对象可以被当作一个方法来使用,这个方法的执行结果与调用这个对象的 find_all() 方法相同,下面两行代码是等价的:
soup.find_all("a")
soup("a")
这两行代码也是等价的:
soup.title.find_all(text=True)
soup.title(text=True)
'''
4.2.3.3 find
# find( name , attrs , recursive , text , **kwargs )
find_all() 方法将返回文档中符合条件的所有tag,尽管有时候我们只想得到一个结果.比如文档中只有一个<body>标签,那么使用 find_all() 方法来查找<body>标签就不太合适, 使用 find_all 方法并设置 limit=1 参数不如直接使用 find() 方法.下面两行代码是等价的:
soup.find_all('title', limit=1)
# [<title>The Dormouse's story</title>]
soup.find('title')
# <title>The Dormouse's story</title>
唯一的区别是 find_all() 方法的返回结果是值包含一个元素的列表,而 find() 方法直接返回结果.
find_all() 方法没有找到目标是返回空列表, find() 方法找不到目标时,返回 None .
print(soup.find("nosuchtag"))
# None
soup.head.title 是 tag的名字 方法的简写.这个简写的原理就是多次调用当前tag的 find() 方法:
soup.head.title
# <title>The Dormouse's story</title>
soup.find("head").find("title")
# <title>The Dormouse's story</title>
https://www.crummy.com/software/BeautifulSoup/bs4/doc/index.zh.html#find-parents-find-parent
4.2.3.4 修改文档树
https://www.crummy.com/software/BeautifulSoup/bs4/doc/index.zh.html#id40
4.2.3.5 CSS选择器
# 该模块提供了select方法来支持css,详见官网:https://www.crummy.com/software/BeautifulSoup/bs4/doc/index.zh.html#id37
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title">
<b>The Dormouse's story</b>
Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">
<span>Elsie</span>
</a>
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
<div class='panel-1'>
<ul class='list' id='list-1'>
<li class='element'>Foo</li>
<li class='element'>Bar</li>
<li class='element'>Jay</li>
</ul>
<ul class='list list-small' id='list-2'>
<li class='element'><h1 class='yyyy'>Foo</h1></li>
<li class='element xxx'>Bar</li>
<li class='element'>Jay</li>
</ul>
</div>
and they lived at the bottom of a well.
</p>
<p class="story">...</p>
"""
from bs4 import BeautifulSoup
soup=BeautifulSoup(html_doc,'lxml')
#1、CSS选择器
print(soup.p.select('.sister'))
print(soup.select('.sister span'))
print(soup.select('#link1'))
print(soup.select('#link1 span'))
print(soup.select('#list-2 .element.xxx'))
print(soup.select('#list-2')[0].select('.element')) #可以一直select,但其实没必要,一条select就可以了
# 2、获取属性
print(soup.select('#list-2 h1')[0].attrs)
# 3、获取内容
print(soup.select('#list-2 h1')[0].get_text())
4.2.3.6 总结
# 总结:
#1、推荐使用lxml解析库
#2、三种选择器:
标签选择器,find与find_all，css选择器
1、标签选择器筛选功能弱,但是速度快
2、建议使用find,find_all查询匹配单个结果或者多个结果
3、如果对css选择器非常熟悉建议使用select
#3、获取属性attrs和获取文本值get_text()
5 代理池搭建
# 从github下载免费代理池开源代码(建议阅读源代码)
git clone git@github.com:jhao104/proxy_pool.git
# pycharm打开，修改配置文件(reids地址修改)
# 启动爬虫：
python3 proxyPool.py schedule
# 启动服务：
python3 proxyPool.py server
# 随机获取代理
requests.get("http://127.0.0.1:5010/get/").json()
# 删除一个代理
requests.get("http://127.0.0.1:5010/delete/?proxy={}".format(proxy))
6 验证码破解之打码平台
# 验证码破解的方法：
1 图像处理(困难)
pytesseract
百度文字识别
pillow
2 专业打码平台，破解验证码(收费)
# 打码平台：
# 申请超级鹰，注册
# 登录，下载sdk(代码如下)，填入用户名密码，软件id
# !/usr/bin/env python
# coding:utf-8
import requests
from hashlib import md5
class Chaojiying_Client():
def __init__(self, username, password, soft_id):
self.username = username
password = password.encode('utf8')
self.password = md5(password).hexdigest()
self.soft_id = soft_id
self.base_params = {
'user': self.username,
'pass2': self.password,
'softid': self.soft_id,
}
self.headers = {
'Connection': 'Keep-Alive',
'User-Agent': 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0)',
}
def PostPic(self, im, codetype):
"""
im: 图片字节
codetype: 题目类型 参考 http://www.chaojiying.com/price.html
"""
params = {
'codetype': codetype,
}
params.update(self.base_params)
files = {'userfile': ('ccc.jpg', im)}
r = requests.post('http://upload.chaojiying.net/Upload/Processing.php', data=params, files=files, headers=self.headers)
return r.json()
def ReportError(self, im_id):
"""
im_id:报错题目的图片ID
"""
params = {
'id': im_id,
}
params.update(self.base_params)
r = requests.post('http://upload.chaojiying.net/Upload/ReportError.php', data=params, headers=self.headers)
return r.json()
if __name__ == '__main__':
chaojiying = Chaojiying_Client('306334678', 'lqz12345', '903641')
#用户中心>>软件ID 生成一个替换 96001
im = open('a.jpg', 'rb').read()
#本地图片文件路径 来替换 a.jpg 有时WIN系统须要//
print(chaojiying.PostPic(im, 1902))
#1902 验证码类型 官方网站>>价格体系 3.4+版 print 后要加()
7 爬拉勾网职位信息
爬取拉勾网需要先获取第一个页面的cookie，
携带该cookie才能跳转到下一个页面
# https://www.lagou.com/jobs/positionAjax.json?city=%E4%B8%8A%E6%B5%B7&needAddtionalResult=false
import requests
payload = {
'first': 'true',
'pn': '1',
'kd': 'python',
}
header = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36',
'Referer': 'https://www.lagou.com/jobs/list_python?labelWords=&fromSearch=true&suginput=',
'Accept': 'application/json, text/javascript, */*; q=0.01'
}
# 实际要爬取的url
url = 'https://www.lagou.com/jobs/positionAjax.json?needAddtionalResult=false'
# 原始的url
urls ='https://www.lagou.com/jobs/list_python?labelWords=&fromSearch=true&suginput='
# 建立session，可以自动携带cookie
s = requests.Session()
# 获取搜索页的cookies
s.get(urls, headers=header, timeout=3)# 可从s.cookies中获取cookie
# 获取此次文本
response = s.post(url, data=payload, headers=header, timeout=5).text
print(response)
8 爬《三国演义》
# https://www.shicimingju.com/book/sanguoyanyi.html
def write(name, title, content):
with open(f'{name}.txt', 'a', encoding='utf-8') as f:
f.write(title)
f.write('
')
f.write(content)
f.write('
')
for num in range(1,500):
res = requests.get(f'https://www.shicimingju.com/book/sanguoyanyi/{num}.html', )
soup = BeautifulSoup(res.text, 'lxml')
try:
name = soup.select('#nav-top a:last-child')[0].text
title = soup.h1.text
print(title)
content = soup.select(".chapter_content")[0].text
# print(content)
write(name, title, content)
print(f'第{num}章下完了')
# break
except Exception as e:
# print(e)
print(f'{title}下完了')
break
9 爬肯德基门店
# http://www.kfc.com.cn/kfccda/ashx/GetStoreList.ashx?op=keyword
import requests
def write(store_list):
with open('kfc_sh.txt', 'a', encoding='utf-8') as f:
# id = 1
for store in store_list:
f.write(
f"id:{store['rownum']},storeName:{store['storeName']},addressDetail:{store['addressDetail']},pro:{store['pro']}")
f.write('
')
print(f"已下载{store['rownum']}/{num}")
for page in range(1, 20000):
data = {'cname': '上海', 'pid': '', 'pageIndex': page, 'pageSize': 10}
res = requests.post('http://www.kfc.com.cn/kfccda/ashx/GetStoreList.ashx?op=cname', data=data)
# print(res.text)
store_list = res.json().get('Table1')
if not store_list:
break
# print(store_list)
num = res.json().get('Table')[0].get('rowcount')
write(store_list)
10 爬糗事百科段子
#https://www.qiushibaike.com/text/page/2/
import requests
from bs4 import BeautifulSoup
ret=requests.get('https://www.qiushibaike.com/text/page/2/')
# print(ret.text)
soup=BeautifulSoup(ret.text,'html.parser')
article_list=soup.find_all(class_='article')
# print(article_list)
for article in article_list:
content=article.find(class_='content').text
print(content)
print('-------')
11 selenium使用
11.1 selenium简介
selenium最初是一个自动化测试工具,而爬虫中使用它主要是为了解决requests无法直接执行JavaScript代码的问题
selenium本质是通过驱动浏览器，完全模拟浏览器的操作，比如跳转、输入、点击、下拉等，来拿到网页渲染之后的结果，可支持多种浏览器
from selenium import webdriver
browser=webdriver.Chrome()
browser=webdriver.Firefox()
browser=webdriver.PhantomJS()
browser=webdriver.Safari()
browser=webdriver.Edge()
11.2 selenium安装
11.2.1 常规浏览器
#安装：selenium+chromedriver
pip3 install selenium
下载chromdriver.exe放到python安装路径的scripts目录中即可
国内镜像网站地址：http://npm.taobao.org/mirrors/chromedriver/
最新的版本去官网找:https://sites.google.com/a/chromium.org/chromedriver/downloads
#验证安装
C:UsersAdministrator>python3
Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 18:41:36) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
from selenium import webdriver
driver=webdriver.Chrome() #弹出浏览器
driver.get('https://www.baidu.com')
driver.page_source
#注意：
selenium3默认支持的webdriver是Firfox，而Firefox需要安装geckodriver
下载链接：https://github.com/mozilla/geckodriver/releases
11.2.2 无界面浏览器
PhantomJS(不再更新)
#安装：selenium+phantomjs
pip3 install selenium
下载phantomjs，解压后把phantomjs.exe所在的bin目录放到环境变量
下载链接：http://phantomjs.org/download.html
#验证安装
C:UsersAdministrator>phantomjs
phantomjs> console.log('egon gaga')
egon gaga
undefined
phantomjs>
C:UsersAdministrator>python3
Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 18:41:36) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
from selenium import webdriver
driver=webdriver.PhantomJS() #无界面浏览器
driver.get('https://www.baidu.com')
driver.page_source
在 PhantomJS 年久失修, 后继无人的节骨眼
Chrome 出来救场, 再次成为了反爬虫 Team 的噩梦
自Google 发布 chrome 59 / 60 正式版 开始便支持Headless mode
这意味着在无 GUI 环境下, PhantomJS 不再是唯一选择
# selenium:3.12.0
# webdriver:2.38
# chrome.exe: 65.0.3325.181(正式版本) (32 位)
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
chrome_options = Options()
chrome_options.add_argument('window-size=1920x3000') # 指定浏览器分辨率
chrome_options.add_argument('--disable-gpu') # 谷歌文档提到需要加上这个属性来规避bug
chrome_options.add_argument('--hide-scrollbars') # 隐藏滚动条, 应对一些特殊页面
chrome_options.add_argument('blink-settings=imagesEnabled=false') #不加载图片, 提升速度
chrome_options.add_argument('--headless') # 浏览器不提供可视化页面. linux下如果系统不支持可视化不加这条会启动失败
bro=webdriver.Chrome(chrome_options=chrome_options,executable_path='./chromedriver.exe')
driver.get('https://www.baidu.com')
print(bro.page_source)
print('hao123' in driver.page_source)
driver.close() #切记关闭浏览器，回收资源
11.3 selenium基本使用
from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By # 按照什么方式查找，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys # 键盘按键操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait # 等待页面加载某些元素
browser = webdriver.Chrome(executable_path='./chromedriver.exe') # 指定驱动
# 打开一个Chrome浏览器
try:
browser.get('https://www.baidu.com') # 输入url地址
input_tag = browser.find_element_by_id('kw') # 找到搜索框
input_tag.send_keys('美女') # 在搜索框中加入内容 python2中输入中文错误，字符串前加个u
input_tag.send_keys(Keys.ENTER) # 输入回车
wait = WebDriverWait(browser, 10)
wait.until(EC.presence_of_element_located((By.ID, 'content_left'))) # 等到id为content_left的元素加载完毕,最多等10秒
print(browser.page_source)
print(browser.current_url)
print(browser.get_cookies())
finally:
browser.close()
11.4 selenium的选择器
# 官网链接：http://selenium-python.readthedocs.io/locating-elements.html
#===============所有方法===================
# 1、find_element_by_id # 通过id查找标签
# 2、find_element_by_link_text # 通过链接文本查找链接标签
# 3、find_element_by_partial_link_text # 通过链接的部分文本查找链接标签
# 4、find_element_by_tag_name # 通过标签(span)查找标签
# 5、find_element_by_class_name # 通过标签class查找标签
# 6、find_element_by_name # 通过标签name属性查找标签
# 7、find_element_by_css_selector # 通过css选择器查找标签
# 8、find_element_by_xpath # 通过xpath查找标签
# 强调：
# 1、上述均可以改写成find_element(By.ID,'kw')的形式
# 2、find_elements_by_xxx的形式是查找到多个元素，结果为列表
from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By #按照什么方式查找，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys #键盘按键操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait #等待页面加载某些元素
import time
driver=webdriver.Chrome(executable_path='./chromedriver.exe')
driver.get('https://www.baidu.com')
wait=WebDriverWait(driver,10)
#===============示范用法===================
# 1、find_element_by_id
print(driver.find_element_by_id('kw'))
# 查找id为kw的标签
# 2、find_element_by_link_text
login=driver.find_element_by_link_text('登录')
login.click()
# 查找链接文本为登录的链接标签，并点击它
# 3、find_element_by_partial_link_text
login=driver.find_elements_by_partial_link_text('录')[0]
login.click()
# 查找链接文本中有录的链接标签，并点击它
# 4、find_element_by_tag_name
print(driver.find_element_by_tag_name('a'))
# 查找第一个a标签
# 5、find_element_by_class_name
button=wait.until(EC.element_to_be_clickable((By.CLASS_NAME,'tang-pass-footerBarULogin')))
button.click()
# 查找class为tang-pass-footerBarULogin的标签，并点击它
# 6、find_element_by_name
input_user=wait.until(EC.presence_of_element_located((By.NAME,'userName')))
input_pwd=wait.until(EC.presence_of_element_located((By.NAME,'password')))
commit=wait.until(EC.element_to_be_clickable((By.ID,'TANGRAM__PSP_10__submit')))
# 查找name属性为userName和password的标签
input_user.send_keys('18611453110')
# 在input标签内输入18611453110
input_pwd.send_keys('xxxxxx')
# 在input标签内输入xxxxxx
commit.click()
# 点击登录
# 7、find_element_by_css_selector
driver.find_element_by_css_selector('#kw')
# 查找id为kw的标签(css选择器)
# 8、find_element_by_xpath
driver.find_element_by_xpath('//a')
# 查找所有a标签(xpath)
11.5 模拟登录百度
# 模拟登陆百度
from selenium import webdriver
import time
bro = webdriver.Chrome(executable_path='./chromedriver.exe')
bro.get('https://www.baidu.com/')
time.sleep(0.01)
input_k = bro.find_element_by_id('kw')
input_k.send_keys('美女') # 在框里写入美女
time.sleep(2)
sou = bro.find_element_by_id('su') # 找到搜索按钮
sou.click() # 点击搜索按钮
time.sleep(4)
bro.close()
from selenium import webdriver
import time
bro = webdriver.Chrome(executable_path='./chromedriver.exe')
bro.implicitly_wait(5) # 隐式等待：找一个控件，如果控件没有加载出来，等待5s中 等待所有，只需要写着一句，以后找所有控件都按这个操作来
bro.get('https://www.baidu.com/')
d_button = bro.find_element_by_link_text('登录')
d_button.click()
login_u = bro.find_element_by_id('TANGRAM__PSP_11__footerULoginBtn')
login_u.click()
username = bro.find_element_by_id('TANGRAM__PSP_11__userName')
username.send_keys('yxp654799481')
password = bro.find_element_by_id('TANGRAM__PSP_11__password')
password.send_keys('yxp997997')
time.sleep(3)
submit = bro.find_element_by_id('TANGRAM__PSP_11__submit')
submit.click()
time.sleep(10)
print(bro.get_cookies())
bro.close()
11.6 xpath选择器使用
# xpath: XPath 是一门在 XML 文档中查找信息的语言
# / :从根节点选取。
# // :不管位置，直接找
# /@属性名 获取属性
# /text() 获取文本内容
# 可以从浏览器复制(copy xpath)
doc = '''
<html>
<head>
<base href='http://example.com/' />
<title>Example website</title>
</head>
<body>
<div id='images'>
<a href='image1.html'>Name: My image 1 <br /><img src='image1_thumb.jpg' /></a>
<a href='image2.html'>Name: My image 2 <br /><img src='image2_thumb.jpg' /></a>
<a href='image3.html'>Name: My image 3 <br /><img src='image3_thumb.jpg' /></a>
<a href='image4.html'>Name: My image 4 <br /><img src='image4_thumb.jpg' /></a>
<a href='image5.html' class='li li-item' name='items'>Name: My image 5 <br /><img src='image5_thumb.jpg' /></a>
<a href='image6.html' name='items'><span><h5>test</h5></span>Name: My image 6 <br /><img src='image6_thumb.jpg' /></a>
</div>
</body>
</html>
'''
from lxml import etree
html = etree.HTML(doc)
# html=etree.parse('search.html',etree.HTMLParser())
# 1 所有节点
a = html.xpath('//*')
# 2 指定节点(结果为列表)
a = html.xpath('//head')
# 3 子节点，子孙节点
a = html.xpath('//div/a')
a = html.xpath('//body/a') # 无数据
a = html.xpath('//body//a')
# 4 父节点
a = html.xpath('//body//a[@href="image1.html"]/..')
a = html.xpath('//body//a[1]/..')
# 也可以这样
a = html.xpath('//body//a[1]/parent::*')
# 5 属性匹配
a = html.xpath('//body//a[@href="image1.html"]')
# 6 文本获取 /text() 取当前标签的文本
a = html.xpath('//body//a[@href="image1.html"]/text()')
# 7 属性获取 @href 取当前标签的属性
a = html.xpath('//body//a/@href')
# 注意从1 开始取(不是从0)
a = html.xpath('//body//a[1]/@href')
# 8 属性多值匹配
# a 标签有多个class类，直接匹配就不可以了，需要用contains
a = html.xpath('//body//a[@class="li"]')
a = html.xpath('//body//a[contains(@class,"li")]')
a = html.xpath('//body//a[contains(@class,"li")]/text()')
# 9 多属性匹配
a = html.xpath('//body//a[contains(@class,"li") or @name="items"]')
a = html.xpath('//body//a[contains(@class,"li") and @name="items"]/text()')
# a=html.xpath('//body//a[contains(@class,"li")]/text()')
# 10 按序选择
a = html.xpath('//a[2]/text()')
a = html.xpath('//a[2]/@href')
# 取最后一个
a = html.xpath('//a[last()]/@href')
# 位置小于3的
a = html.xpath('//a[position()<3]/@href')
# 倒数第二个
a = html.xpath('//a[last()-2]/@href')
# 11 节点轴选择
# ancestor：祖先节点
# 使用了* 获取所有祖先节点
a = html.xpath('//a/ancestor::*')
# 获取祖先节点中的div
a = html.xpath('//a/ancestor::div')
# attribute：属性值
a = html.xpath('//a[1]/attribute::*')
# child：直接子节点
a = html.xpath('//a[1]/child::*')
# descendant：所有子孙节点
a = html.xpath('//a[6]/descendant::*')
# following:当前节点之后所有节点
a = html.xpath('//a[1]/following::*')
a = html.xpath('//a[1]/following::*[1]/@href')
# following-sibling:当前节点之后同级节点
a = html.xpath('//a[1]/following-sibling::*')
a = html.xpath('//a[1]/following-sibling::a')
a = html.xpath('//a[1]/following-sibling::*[2]')
a = html.xpath('//a[1]/following-sibling::*[2]/@href')
print(a)
# 官网链接：http://selenium-python.readthedocs.io/locating-elements.html
from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By # 按照什么方式查找，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys # 键盘按键操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait # 等待页面加载某些元素
import time
driver = webdriver.PhantomJS()
driver.get('https://doc.scrapy.org/en/latest/_static/selectors-sample1.html')
# wait=WebDriverWait(driver,3)
driver.implicitly_wait(3) # 使用隐式等待
try:
# find_element_by_xpath
# //与/
# driver.find_element_by_xpath('//body/a') # 开头的//代表从整篇文档中寻找,body之后的/代表body的儿子，这一行找不到就会报错了
driver.find_element_by_xpath('//body//a') # 开头的//代表从整篇文档中寻找,body之后的//代表body的子子孙孙
driver.find_element_by_css_selector('body a')
# 取第n个
res1 = driver.find_elements_by_xpath('//body//a[1]') # 取第一个a标签
print(res1[0].text)
# 按照属性查找,下述三者查找效果一样
res1 = driver.find_element_by_xpath('//a[5]')
res2 = driver.find_element_by_xpath('//a[@href="image5.html"]')
res3 = driver.find_element_by_xpath('//a[contains(@href,"image5")]') # 模糊查找
print('==>', res1.text)
print('==>', res2.text)
print('==>', res3.text)
# 其他
res1 = driver.find_element_by_xpath('/html/body/div/a')
print(res1.text)
res2 = driver.find_element_by_xpath('//a[img/@src="image3_thumb.jpg"]')
# 找到子标签img的src属性为image3_thumb.jpg的a标签
print(res2.tag_name, res2.text)
res3 = driver.find_element_by_xpath("//input[@name='continue'][@type='button']")
# 查看属性name为continue且属性type为button的input标签
res4 = driver.find_element_by_xpath("//*[@name='continue'][@type='button']")
# 查看属性name为continue且属性type为button的所有标签
time.sleep(5)
finally:
driver.close()
11.7 selenium标签的属性
.text
.location
.size
.get_attribute('href')
.get_cookies()
from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By #按照什么方式查找，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys #键盘按键操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait #等待页面加载某些元素
browser=webdriver.Chrome()
browser.get('https://www.amazon.cn/')
wait=WebDriverWait(browser,10)
wait.until(EC.presence_of_element_located((By.ID,'cc-lm-tcgShowImgContainer')))
tag=browser.find_element(By.CSS_SELECTOR,'#cc-lm-tcgShowImgContainer img')
#获取标签属性，
print(tag.text) # 获取文本内容
print(tag.get_attribute('src')) # 获取tag的src属性
#获取标签ID，位置，名称，大小(了解)
print(tag.id)
print(tag.location)
print(tag.tag_name)
print(tag.size)
browser.close()
11.8 隐式等待和显式等待
#1、selenium只是模拟浏览器的行为，而浏览器解析页面是需要时间的(执行css，js)，一些元素可能需要过一段时间才能加载出来，为了保证能查找到元素，必须等待
#2、等待的方式分两种：
隐式等待：在browser.get('xxx')前就设置，针对所有元素有效
显式等待：在browser.get('xxx')之后设置，只针对某个元素有效
11.8.1 隐式等待
from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By # 按照什么方式查找，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys # 键盘按键操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait # 等待页面加载某些元素
browser = webdriver.Chrome()
# 隐式等待:在查找所有元素时，如果尚未被加载，则等10秒
browser.implicitly_wait(10)
browser.get('https://www.baidu.com')
input_tag = browser.find_element_by_id('kw')
input_tag.send_keys('美女')
input_tag.send_keys(Keys.ENTER)
contents = browser.find_element_by_id('content_left') # 没有等待环节而直接查找，找不到则会报错
print(contents)
browser.close()
11.8.2 显式等待
from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By # 按照什么方式查找，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys # 键盘按键操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait # 等待页面加载某些元素
browser = webdriver.Chrome()
browser.get('https://www.baidu.com')
input_tag = browser.find_element_by_id('kw')
input_tag.send_keys('美女')
input_tag.send_keys(Keys.ENTER)
# 显式等待：显式地等待某个元素被加载
wait = WebDriverWait(browser, 10)
wait.until(EC.presence_of_element_located((By.ID, 'content_left')))
contents = browser.find_element(By.CSS_SELECTOR, '#content_left')
print(contents)
browser.close()
11.9 元素交互操作
11.9.1 简单交互
input_tag.clear() # 清空输入框
input_tag.send_keys('iphone7plus') # 在输入框增加内容
button.click() # 点击该标签
input_tag.send_keys(Keys.ENTER) # 按下回车键
browser.execute_script('alert("hello world")') # 执行js代码
from selenium.webdriver.common.keys import Keys # 键盘按键操作
11.9.2 动作链
from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By # 按照什么方式查找，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys # 键盘按键操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait # 等待页面加载某些元素
import time
driver = webdriver.Chrome()
driver.get('http://www.runoob.com/try/try.php?filename=jqueryui-api-droppable')
wait = WebDriverWait(driver, 3)
# driver.implicitly_wait(3) # 使用隐式等待
try:
driver.switch_to.frame('iframeResult') ##切换到iframeResult
sourse = driver.find_element_by_id('draggable')
target = driver.find_element_by_id('droppable')
# 方式一：基于同一个动作链串行执行
# actions=ActionChains(driver) #拿到动作链对象
# actions.drag_and_drop(sourse,target) #把动作放到动作链中，准备串行执行
# actions.perform()
# 方式二：不同的动作链，每次移动的位移都不同
ActionChains(driver).click_and_hold(sourse).perform()
distance = target.location['x'] - sourse.location['x']
track = 0
while track < distance:
ActionChains(driver).move_by_offset(xoffset=2, yoffset=0).perform()
track += 2
ActionChains(driver).release().perform()
time.sleep(10)
finally:
driver.close()
11.9.3 执行js代码
from selenium import webdriver
browser = webdriver.Chrome()
try:
browser.get('https://www.baidu.com')
browser.execute_script('alert("hello world")') # 打印警告
finally:
browser.close()
11.9.4 切换frame
# frame相当于一个单独的网页，在父frame里是无法直接查看到子frame的元素的，必须switch_to_frame切到该frame下，才能进一步查找
from selenium import webdriver
browser = webdriver.Chrome()
try:
browser.get('http://www.runoob.com/try/try.php?filename=jqueryui-api-droppable')
browser.switch_to.frame('iframeResult') # 切换到id为iframeResult的frame
tag1 = browser.find_element_by_id('droppable')
print(tag1)
# tag2=browser.find_element_by_id('textareaCode')
# 报错，在子frame里无法查看到父frame的元素
browser.switch_to.parent_frame() # 切回父frame,就可以查找到了
tag2 = browser.find_element_by_id('textareaCode')
print(tag2)
finally:
browser.close()
11.10 其他
11.10.1 模拟浏览器的前进后退
import time
from selenium import webdriver
browser=webdriver.Chrome()
browser.get('https://www.baidu.com')
browser.get('https://www.taobao.com')
browser.get('http://www.sina.com.cn/')
browser.back()
time.sleep(10)
browser.forward()
browser.close()
# 如何把屏幕拉倒最后(js控制)
# bro.execute_script('window.scrollTo(0,document.body.offsetHeight)')
11.10.2 获取cookie
from selenium import webdriver
browser=webdriver.Chrome()
browser.get('https://www.zhihu.com/explore')
print(browser.get_cookies())
browser.add_cookie({'k1':'xxx','k2':'yyy'})
print(browser.get_cookies())
# browser.delete_all_cookies()
11.10.3 选项卡管理
# 选项卡管理：切换选项卡，有js的方式windows.open,有windows快捷键：ctrl+t等，最通用的就是js的方式
import time
from selenium import webdriver
browser=webdriver.Chrome()
browser.get('https://www.baidu.com')
browser.execute_script('window.open()')
print(browser.window_handles) #获取所有的选项卡
browser.switch_to_window(browser.window_handles[1])
browser.get('https://www.taobao.com')
time.sleep(10)
browser.switch_to_window(browser.window_handles[0])
browser.get('https://www.sina.com.cn')
browser.close()
11.10.4 异常处理
from selenium import webdriver
from selenium.common.exceptions import TimeoutException,NoSuchElementException,NoSuchFrameException
try:
browser=webdriver.Chrome()
browser.get('http://www.runoob.com/try/try.php?filename=jqueryui-api-droppable')
browser.switch_to.frame('iframssseResult')
except TimeoutException as e:
print(e)
except NoSuchFrameException as e:
print(e)
finally:
browser.close()
12 爬取京东商品信息
from selenium import webdriver
import time
# 模拟键盘输入
from selenium.webdriver.common.keys import Keys
bro=webdriver.Chrome(executable_path='./chromedriver.exe')
# 设置隐士等待
bro.implicitly_wait(10)
def get_goods_info(bro):
# li_list=bro.find_element_by_class_name('gl-warp').find_elements_by_tag_name('li')
# goods=bro.find_elements_by_class_name('gl-item')
goods = bro.find_elements_by_css_selector('.gl-item')
# print(len(goods))
for good in goods:
try:
price = good.find_element_by_css_selector('.p-price i').text
name = good.find_element_by_css_selector('.p-name em').text
url = good.find_element_by_css_selector('.p-img a').get_attribute('href')
commits = good.find_element_by_css_selector('.p-commit strong>a').text
photo_url = good.find_element_by_css_selector('.p-img img').get_attribute('src')
print('''
商品名字：%s
商品价格：%s
商品地址：%s
商品评论数：%s
商品图片地址：%s
''' % (name, price, url, commits, photo_url))
except Exception as e:
continue
next_button = bro.find_element_by_partial_link_text('下一页')
time.sleep(1)
next_button.click()
get_goods_info(bro)
try:
bro.get('https://www.jd.com/')
input_k=bro.find_element_by_id('key')
input_k.send_keys('奶牛')
# 模拟键盘的回车键
input_k.send_keys(Keys.ENTER)
get_goods_info(bro)
except Exception as e:
print(e)
finally:
bro.close()
13 自动登录12306
from selenium import webdriver
import time
# pip install pillow
from PIL import Image
# 引入超级鹰
from chaojiying import Chaojiying_Client
from selenium.webdriver import ActionChains
bro = webdriver.Chrome(executable_path='./chromedriver.exe')
bro.implicitly_wait(10)
try:
bro.get('https://kyfw.12306.cn/otn/resources/login.html')
bro.maximize_window() # 窗口最大化，全屏
button_z = bro.find_element_by_css_selector('.login-hd-account a')
button_z.click()
time.sleep(2)
# 截取整个屏幕
bro.save_screenshot('./main.png')
# 验证码的位置和大小
img_t = bro.find_element_by_id('J-loginImg')
print(img_t.size)
print(img_t.location)
size = img_t.size
location = img_t.location
img_tu = (
int(location['x']), int(location['y']), int(location['x'] + size['width']), int(location['y'] + size['height']))
# # 抠出验证码
# #打开
img = Image.open('./main.png')
# 抠图
fram = img.crop(img_tu)
# 截出来的小图
fram.save('code.png')
# 调用超级鹰破解
chaojiying = Chaojiying_Client('306334678', 'lqz12345', '903641') # 用户中心>>软件ID 生成一个替换 96001
im = open('code.png', 'rb').read() # 本地图片文件路径 来替换 a.jpg 有时WIN系统须要//
# print(chaojiying.PostPic(im, 9004))
## 返回结果如果有多个 260,133|123，233,处理这种格式[[260,133],[123,233]]
res = chaojiying.PostPic(im, 9004)
print(res)
result = res['pic_str']
all_list = []
if '|' in result:
list_1 = result.split('|')
count_1 = len(list_1)
for i in range(count_1):
xy_list = []
x = int(list_1[i].split(',')[0])
y = int(list_1[i].split(',')[1])
xy_list.append(x)
xy_list.append(y)
all_list.append(xy_list)
else:
x = int(result.split(',')[0])
y = int(result.split(',')[1])
xy_list = []
xy_list.append(x)
xy_list.append(y)
all_list.append(xy_list)
print(all_list)
# 用动作链，点击图片
# [[260,133],[123,233]]
for a in all_list:
x = a[0]
y = a[1]
ActionChains(bro).move_to_element_with_offset(img_t, x, y).click().perform()
time.sleep(1)
username = bro.find_element_by_id('J-userName')
username.send_keys('306334678')
password = bro.find_element_by_id('J-password')
password.send_keys('lqz12345')
time.sleep(3)
submit_login = bro.find_element_by_id('J-login')
submit_login.click()
time.sleep(3)
print(bro.get_cookies())
time.sleep(10)
bro.get('https://www.12306.cn/index/')
time.sleep(5)
except Exception as e:
print(e)
finally:
bro.close()
14 cookie池
# 如何搭建cookie池
# selenium写一套(一堆小号)，跑起脚本，自动登录，手动参与
# 拿到cookie，放到redis中
# django搭建一个服务：127.0.0.0/get,随机返回一个cookie
# request发送请求爬数据(selenium拿到的cookie)，cookie失效
15 抓包工具介绍
# 1 浏览器调试模式
# 2 fiddler，charles(自己研究一下)
16 scrapy
16.1 scrapy简介
# scrapy是通用的网络爬虫框架,爬虫界的django
# scrapy的五大组件
-引擎(EGINE)：引擎负责控制系统所有组件之间的数据流，并在某些动作发生时触发事件
-调度器(SCHEDULER)：用来接受引擎发过来的请求, 压入队列中, 并在引擎再次请求的时候返回. 可以想像成一个URL的优先级队列, 由它来决定下一个要抓取的网址是什么, 同时去除重复的网址
-下载器(DOWLOADER)：用于下载网页内容, 并将网页内容返回给EGINE，下载器是建立在twisted这个高效的异步模型上的
-爬虫(SPIDERS):开发人员自定义的类，用来解析responses，并且提取items，或者发送新的请求request
-项目管道(ITEM PIPLINES):在items被提取后负责处理它们，主要包括清理、验证、持久化(比如存到数据库)等操作
# scrapy的两大中间件
-爬虫中间件：位于EGINE和SPIDERS之间，主要工作是处理SPIDERS的输入和输出(用的很少)
-下载中间件：位于引擎和下载器之间，可以加代理，加请求头，集成selenium
scrapy执行流程，架构图
16.2 scrapy安装
# 1 pip3 install scrapy(mac，linux可以正常执行)
# 2 windows执行该命令，可能能直接成功，少部分人成功不了
# 报错解决方案：
1、pip3 install wheel
# 安装后，便支持通过wheel文件安装软件，wheel文件官网：https://www.lfd.uci.edu/~gohlke/pythonlibs
2、pip3 install lxml
3、pip3 install pyopenssl
4、pip3 install pywin32
5、下载twisted的wheel文件：http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
6、执行pip3 install 下载目录Twisted-17.9.0-cp36-cp36m-win_amd64.whl
7、pip3 install scrapy
# 3 验证安装成功：命令行输入scrapy,有反应即安装完成
Python36Scriptsscrapy.exe 该文件用于创建项目
16.3 scrapy创建项目，创建爬虫，运行爬虫
# 1 创建项目
-scrapy startproject 项目名
-scrapy startproject firstscrapy
# 2 创建爬虫
-scrapy genspider 爬虫名 爬虫地址
-scrapy genspider chouti dig.chouti.com
-执行后会在spider文件夹下创建一个py文件，名字为chouti
# 3 运行爬虫
-scrapy crawl chouti # 输出日志
-scrapy crawl chouti --nolog # 不输出日志
# 4 支持右键执行爬虫
-在项目路径下新建一个main.py
from scrapy.cmdline import execute
execute(['scrapy','crawl','chouti','--nolog'])
16.4 目录介绍
firstscrapy # 项目名字
firstscrapy # 包
-spiders # 包含所有的爬虫文件
-baidu.py # 一个个的爬虫
-chouti.py
-middlewares.py # 中间件(爬虫中间件，下载中间件)
-pipelines.py # 持久化相关(操作items.py中类的对象)
-main.py # 用于执行爬虫(自己创建)
-items.py # 写item类
-settings.py # 配置文件
scrapy.cfg # 上线相关
16.5 settings部分参数
1 默认情况，scrapy会遵循爬虫协议，修改配置文件参数，不遵循协议，强行爬取。
ROBOTSTXT_OBEY = False
2 设置全局USER_AGENT
USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.105 Safari/537.36'
3 设置日志等级LOG_LEVEL
LOG_LEVEL = 'ERROR'
16.6 scrapy的数据解析
# xpath选择：
-response.xpath('//a[contains(@class,"link-title")]/text()').extract() # 取文本
-response.xpath('//a[contains(@class,"link-title")]/@href').extract() # 取属性
# css选择：
-response.css('.link-title::text').extract() # 取文本
-response.css('.link-title::attr(href)').extract_first() # 取属性
response.selector.css()
response.selector.xpath()
可简写为
response.css()
response.xpath()
#1 //与/
response.xpath('//body/a/')#
response.css('div a::text')
response.xpath('//body/a') #开头的//代表从整篇文档中寻找,body之后的/代表body的儿子
[]
response.xpath('//body//a') #开头的//代表从整篇文档中寻找,body之后的//代表body的子子孙孙
[<Selector xpath='//body//a' data='<a href="image1.html">Name: My image 1 <'>, <Selector xpath='//body//a' data='<a href="image2.html">Name: My image 2 <'>, <Selector xpath='//body//a' data='<a href="
image3.html">Name: My image 3 <'>, <Selector xpath='//body//a' data='<a href="image4.html">Name: My image 4 <'>, <Selector xpath='//body//a' data='<a href="image5.html">Name: My image 5 <'>]
#2 text
response.xpath('//body//a/text()')
response.css('body a::text')
#3、extract与extract_first:从selector对象中解出内容
response.xpath('//div/a/text()').extract()
['Name: My image 1 ', 'Name: My image 2 ', 'Name: My image 3 ', 'Name: My image 4 ', 'Name: My image 5 ']
response.css('div a::text').extract()
['Name: My image 1 ', 'Name: My image 2 ', 'Name: My image 3 ', 'Name: My image 4 ', 'Name: My image 5 ']
response.xpath('//div/a/text()').extract_first()
'Name: My image 1 '
response.css('div a::text').extract_first()
'Name: My image 1 '
#4、属性：xpath的属性加前缀@
response.xpath('//div/a/@href').extract_first()
'image1.html'
response.css('div a::attr(href)').extract_first()
'image1.html'
#4、嵌套查找
response.xpath('//div').css('a').xpath('@href').extract_first()
'image1.html'
#5、设置默认值
response.xpath('//div[@id="xxx"]').extract_first(default="not found")
'not found'
#4、按照属性查找
response.xpath('//div[@id="images"]/a[@href="image3.html"]/text()').extract()
response.css('#images a[@href="image3.html"]/text()').extract()
#5、按照属性模糊查找
response.xpath('//a[contains(@href,"image")]/@href').extract()
response.css('a[href*="image"]::attr(href)').extract()
response.xpath('//a[contains(@href,"image")]/img/@src').extract()
response.css('a[href*="imag"] img::attr(src)').extract()
response.xpath('//*[@href="image1.html"]')
response.css('*[href="image1.html"]')
#6、正则表达式
response.xpath('//a/text()').re(r'Name: (.*)')
response.xpath('//a/text()').re_first(r'Name: (.*)')
#7、xpath相对路径
res=response.xpath('//a[contains(@href,"3")]')[0]
res.xpath('img')
[<Selector xpath='img' data='<img src="image3_thumb.jpg">'>]
res.xpath('./img')
[<Selector xpath='./img' data='<img src="image3_thumb.jpg">'>]
res.xpath('.//img')
[<Selector xpath='.//img' data='<img src="image3_thumb.jpg">'>]
res.xpath('//img') #这就是从头开始扫描
[<Selector xpath='//img' data='<img src="image1_thumb.jpg">'>, <Selector xpath='//img' data='<img src="image2_thumb.jpg">'>, <Selector xpath='//img' data='<img src="image3_thumb.jpg">'>, <Selector xpa
th='//img' data='<img src="image4_thumb.jpg">'>, <Selector xpath='//img' data='<img src="image5_thumb.jpg">'>]
#8、带变量的xpath
response.xpath('//div[@id=$xxx]/a/text()',xxx='images').extract_first()
'Name: My image 1 '
response.xpath('//div[count(a)=$yyy]/@id',yyy=5).extract_first() #求有5个a标签的div的id
'images'
16.7 scrapy的持久化存储
# 1 方案一：
parser函数必须返回列表套字典的形式(了解)
执行命令：scrapy crawl 爬虫名 -o 文件名
# 2 方案二：通过pipline，item存储(mysql，redis，文件)
-在Items.py中写一个类
-在spider中导入，实例化，把数据放进去
item['title']=title
item['url']=url
item['photo_url']=photo_url
yield item
-在setting中配置(数字越小，级别越高)
ITEM_PIPELINES = {
'firstscrapy.pipelines.ChoutiFilePipeline': 300,
}
-在pipelines.py中写ChoutiFilePipeline
-open_spider(开始的时候)
-close_spider(结束的时候)
-process_item(在这持久化)
# 方案2
# items.py
import scrapy
class ChoutiItem(scrapy.Item):
title = scrapy.Field()
url = scrapy.Field()
photo_url = scrapy.Field()
# pipelines.py
class ChoutiFilePipeline(object):
def open_spider(self,spider):
print('打开文件')
self.file = open('chouti.txt','w',encoding='utf-8')
def process_item(self, item, spider):
print('111')
self.file.write(item['title']+'
')
self.file.write(item['url']+'
')
self.file.write(item['photo_url']+'
')
return item
def close_spider(self,spider):
print('关闭文件')
self.file.close()
# settings.py
ITEM_PIPELINES = {
'firstscrapy.pipelines.ChoutiFilePipeline': 300,
}
16.8 scrapy命令
#1 查看帮助
scrapy -h
scrapy <command> -h
#2 有两种命令：其中Project-only必须切到项目文件夹下才能执行，而Global的命令则不需要
Global commands:
startproject #创建项目
genspider #创建爬虫程序
settings #如果是在项目目录下，则得到的是该项目的配置
runspider #运行一个独立的python文件，不必创建项目
shell #scrapy shell url地址 在交互式调试，如选择器规则正确与否
fetch #独立于程单纯地爬取一个页面，可以拿到请求头
view #下载完毕后直接弹出浏览器，以此可以分辨出哪些数据是ajax请求
version #scrapy version 查看scrapy的版本，scrapy version -v查看scrapy依赖库的版本
Project-only commands:
crawl #运行爬虫，必须创建项目才行，确保配置文件中ROBOTSTXT_OBEY = False
check #检测项目中有无语法错误
list #列出项目中所包含的爬虫名
edit #编辑器，一般不用
parse #scrapy parse url地址 --callback 回调函数 #以此可以验证我们的回调函数是否正确
bench #scrapy bentch压力测试
#3 官网链接
https://docs.scrapy.org/en/latest/topics/commands.html
17 爬取抽屉新闻
# chouti.py
import scrapy
from scrapy.http.request import Request
from bs4 import BeautifulSoup
from firstscrapy.items import ChoutiItem
class ChoutiSpider(scrapy.Spider):
name = 'chouti'
allowed_domains = ['dig.chouti.com']
start_urls = ['http://dig.chouti.com/']
def parse(self, response):
div_list=response.xpath('//div[contains(@class,"link-item")]')
for div in div_list:
item = ChoutiItem()
title=div.css('.link-title::text').extract_first()
url=div.css('.link-title::attr(href)').extract_first()
photo_url=div.css('.image-scale::attr(src)').extract_first()
if not photo_url:
photo_url=''
item['title']=title
item['url']=url
item['photo_url']=photo_url
yield item
# 注意要用yield
# items.py
import scrapy
class ChoutiItem(scrapy.Item):
title = scrapy.Field()
url = scrapy.Field()
photo_url = scrapy.Field()
# pipelines.py
import pymysql
class ChoutiFilePipeline(object):
def open_spider(self,spider):
print('打开文件')
self.file=open('chouti.txt','w',encoding='utf-8')
def process_item(self, item, spider):
self.file.write(item['title']+'
')
self.file.write(item['url']+'
')
self.file.write(item['photo_url']+'
')
return item
def close_spider(self,spider):
print('关闭文件')
self.file.close()
class ChoutiMysqlPipeline(object):
def open_spider(self,spider):
self.conn=pymysql.connect( host='127.0.0.1', user='root', password="123",
database='chouti', port=3306)
def close_spider(self,spider):
self.conn.close()
def process_item(self, item, spider):
cursor=self.conn.cursor()
sql='insert into article (title,url,photo_url)values(%s,%s,%s) '
cursor.execute(sql,[item['title'],item['url'],item['photo_url']])
self.conn.commit()
return item
18 自动点赞
from selenium import webdriver
import time
bro = webdriver.Chrome(executable_path=r'chromedriver.exe')
bro.implicitly_wait(5)
bro.get('https://dig.chouti.com/')
bro.maximize_window()
login_show = bro.find_element_by_id('login_btn')
login_show.click()
username = bro.find_element_by_name('phone')
username.send_keys('13212106712')
password = bro.find_element_by_name('password')
password.send_keys('wwh123')
login_button = bro.find_element_by_css_selector('button.login-btn')
login_button.click()
time.sleep(10)
# 可能有验证码，手动操作一下
with open('cookie.txt','w',encoding='utf-8') as f:
f.write(str(bro.get_cookies()))
# 这个cookie不是一个字典，不能直接给requests使用，需要转一下
bro.close()
# ===================================================================================
import requests
from bs4 import BeautifulSoup
# 这个cookie不是一个字典，不能直接给requests使用，需要转一下
with open('cookie.txt', 'rb') as f:
cookie = f.read()
cookies = eval(cookie)
cookie = {}
for i in cookies:
cookie[i['name']] = i['value']
headers = {
'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.97 Safari/537.36',
'referer': 'https://dig.chouti.com/',
}
res = requests.get('https://dig.chouti.com/', cookies=cookie, headers=headers)
soup = BeautifulSoup(res.text,'lxml')
divs = soup.select('.link-con .link-item')
ll = []
for div in divs:
id = div.get('data-id')
ll.append(id)
print(ll)
res = requests.get('https://dig.chouti.com/top/24hr?_=159671243913', cookies=cookie, headers=headers, )
# print(res.json())
for item in res.json()['data']:
ll.append(item['id'])
res = requests.get('https://dig.chouti.com/top/72hr?_=1596712861433', cookies=cookie, headers=headers, )
for item in res.json()['data']:
ll.append(item['id'])
res = requests.get('https://dig.chouti.com/top/168hr?_=1596712861434', cookies=cookie, headers=headers, )
for item in res.json()['data']:
ll.append(item['id'])
print(ll)
# https://dig.chouti.com/link/cancel/vote
# linkId: 29832226
headers['content-length'] = '15'
for id in ll:
res = requests.post('https://dig.chouti.com/link/vote', cookies=cookie, headers=headers, data={'linkId': id})
print(res.text)
19 爬取cnblogs全站
# cnblog.py
import scrapy
from scrapy.http import Request
from ..items import CNBlogItem
# 爬取cnblogs文章，把标题连接地址和文章内容保存到mysql，连续爬取n页
class CnblogSpider(scrapy.Spider):
name = 'cnblog'
allowed_domains = ['www.cnblogs.com']
start_urls = ['http://www.cnblogs.com/']
def parse(self, response):
articles = response.css('#post_list article')
for article in articles:
item = CNBlogItem()
title = article.css('.post-item-title::text').extract_first()
url = article.css('.post-item-title::attr(href)').extract_first()
print(title)
item['title'] = title
item['url'] = url
request = Request(url, callback=self.parse_content)
# 需要先爬取文章内容，为了将文章存入item，需要将item传递
request.meta['item'] = item
# 爬完后回调到parse_content继续执行代码
yield request
# 当页所有文章爬完后，获取下一页的url，继续请求，回调parse继续执行代码
next_page = response.css('.pager a:last-child::attr(href)').extract_first()
next_url = 'http://www.cnblogs.com' + next_page
yield Request(next_url, callback=self.parse)
def parse_content(self, response):
item = response.meta.get('item')
article = response.css('#topics').extract_first()
item['content'] = article
# print(item)
return item
pass
# ====================================================================================
class CNBlogItem(scrapy.Item):
title = scrapy.Field()
url = scrapy.Field()
content = scrapy.Field()
20 scrapy的请求传参
# 把要传递的数据放到meta中
yield Request(url,meta={'item':item})
# 在response对象中取出来
item=response.meta.get('item')
21 提升scrapy爬取数据效率
- 在配置文件中进行相关的配置即可:(默认还有一套setting)
#1 增加并发：
默认scrapy开启的并发线程为32个，可以适当进行增加。在settings配置文件中修改CONCURRENT_REQUESTS = 100值为100,并发设置成了为100。
#2 降低日志级别：
在运行scrapy时，会有大量日志信息的输出，为了减少CPU的使用率。可以设置log输出信息为INFO或者ERROR即可。在配置文件中编写：LOG_LEVEL = ‘INFO’
# 3 禁止cookie：
如果不是真的需要cookie，则在scrapy爬取数据时可以禁止cookie从而减少CPU的使用率，提升爬取效率。在配置文件中编写：COOKIES_ENABLED = False
# 4禁止重试：
对失败的HTTP进行重新请求(重试)会减慢爬取速度，因此可以禁止重试。在配置文件中编写：RETRY_ENABLED = False
# 5 减少下载超时：
如果对一个非常慢的链接进行爬取，减少下载超时可以能让卡住的链接快速被放弃，从而提升效率。在配置文件中进行编写：DOWNLOAD_TIMEOUT = 10 超时时间为10s
22 scrapy的中间件
# 爬虫中间件,下载中间件都写在middlewares.py
# 记得配置：配置文件
# 下载中间件
- process_request：返回不同的对象，后续处理不同(加代理...)
# 1 更换请求头
print(type(request.headers)) # Headers对象，继承了dict
# from scrapy.http.headers import Headers
request.headers['User-Agent']='xxx'
# 2 加cookie ---cookie池
# 假设已经搭建好cookie池
request.cookies={'username':'xxxx'}
# 3 加代理 -----代理池
print(request.meta)
request.meta['download_timeout'] = 20
request.meta["proxy"] = 'http://27.188.62.3:8060'
- process_response：返回不同的对象，后续处理不同
- process_exception
def process_exception(self, request, exception, spider):
print('xxxx')
# request.url='https://www.baidu.com'
# 不允许直接修改request的url，创建新的request对象
from scrapy import Request
request=Request(url='https://www.baidu.com',callback=spider.parser)
return request
23 在scrapy中的使用selenium
# 注意：使用同一个浏览器
# 1 在爬虫中初始化webdriver对象
from selenium import webdriver
class CnblogSpider(scrapy.Spider):
name = 'cnblog'
...
bro = webdriver.Chrome(executable_path='chromedriver.exe')
# 2 在中间件中使用(process_request)
spider.bro.get('https://dig.chouti.com/')
response = HtmlResponse(url='https://dig.chouti.com/',
body=spider.bro.page_source.encode('utf-8'),
request=request)
return response
# 3 在爬虫中关闭
def close(self, reason):
print("我结束了")
self.bro.close()
24 去重规则源码分析
# scrapy模块的默认去重配置为：
DUPEFILTER_CLASS = 'scrapy.dupefilters.RFPDupeFilter'
# scrapy/dupefilters.py
class RFPDupeFilter(BaseDupeFilter):
"""Request Fingerprint duplicates filter"""
def __init__(self, path=None, debug=False):
self.fingerprints = set() # 使用集合去重
def request_seen(self, request):
fp = self.request_fingerprint(request)
# fp是指纹，即使 查询参数 顺序不同也能识别
# http://www.example.com/query?id=111&cat=222
# http://www.example.com/query?cat=222&id=111
# 内部使用sha1加密处理(hash)添加了请求方式，请求体等
if fp in self.fingerprints: # 如果已存在就返回True
return True
self.fingerprints.add(fp) # 不存在则添加入集合
if self.file:
self.file.write(fp + '
')
25 分布式爬虫(scrapy-redis)
# 1 pip3 install scrapy-redis
# 2 爬虫原来继承Spider，现在需要继承RedisSpider
# 3 不能写start_urls = ['https:/www.cnblogs.com/']
# 4 需要写redis_key = 'myspider:start_urls'
# 5 setting中配置：
# redis的连接
REDIS_HOST = 'localhost' # 主机名
REDIS_PORT = 6379 # 端口
# 使用scrapy-redis的去重
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
# 使用scrapy-redis的Scheduler
# 分布式爬虫的配置
SCHEDULER = "scrapy_redis.scheduler.Scheduler"
# 持久化的可以配置，也可以不配置
ITEM_PIPELINES = {
'scrapy_redis.pipelines.RedisPipeline': 299
}
# 6 去redis中以myspider:start_urls为key，插入一个起始地址
lpush myspider:start_urls https://www.cnblogs.com/
26 破解知乎登陆(js逆向和解密)
client_id=c3cef7c66a1843f8b3a9e6a1e3160e20&
grant_type=password&
timestamp=1596702006088&
source=com.zhihu.web&
signature=eac4a6c461f9edf86ef33ef950c7b6aa426dbb39&
username=%2B86liuqingzheng&
password=1111111&
captcha=&
lang=en&
utm_source=&
ref_source=other_https%3A%2F%2Fwww.zhihu.com%2Fsignin%3Fnext%3D%252F"
# 破解知乎登陆
import requests #请求解析库
import base64 #base64解密加密库
from PIL import Image #图片处理库
import hmac #加密库
from hashlib import sha1 #加密库
import time
from urllib.parse import urlencode #url编码库
import execjs #python调用node.js
from http import cookiejar as cookielib
class Spider():
def __init__(self):
self.session = requests.session()
self.session.cookies = cookielib.LWPCookieJar() #使cookie可以调用save和load方法
self.login_page_url = 'https://www.zhihu.com/signin?next=%2F'
self.login_api = 'https://www.zhihu.com/api/v3/oauth/sign_in'
self.captcha_api = 'https://www.zhihu.com/api/v3/oauth/captcha?lang=en'
self.headers = {
'user-agent':'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.98 Safari/537.36 LBBROWSER',
}
self.captcha ='' #存验证码
self.signature = '' #存签名
# 首次请求获取cookie
def get_base_cookie(self):
self.session.get(url=self.login_page_url, headers=self.headers)
def deal_captcha(self):
r = self.session.get(url=self.captcha_api, headers=self.headers)
r = r.json()
if r.get('show_captcha'):
while True:
r = self.session.put(url=self.captcha_api, headers=self.headers)
img_base64 = r.json().get('img_base64')
with open('captcha.png', 'wb') as f:
f.write(base64.b64decode(img_base64))
captcha_img = Image.open('captcha.png')
captcha_img.show()
self.captcha = input('输入验证码:')
r = self.session.post(url=self.captcha_api, data={'input_text': self.captcha},
headers=self.headers)
if r.json().get('success'):
break
def get_signature(self):
# 生成加密签名
a = hmac.new(b'd1b964811afb40118a12068ff74a12f4', digestmod=sha1)
a.update(b'password')
a.update(b'c3cef7c66a1843f8b3a9e6a1e3160e20')
a.update(b'com.zhihu.web')
a.update(str(int(time.time() * 1000)).encode('utf-8'))
self.signature = a.hexdigest()
def post_login_data(self):
data = {
'client_id': 'c3cef7c66a1843f8b3a9e6a1e3160e20',
'grant_type': 'password',
'timestamp': str(int(time.time() * 1000)),
'source': 'com.zhihu.web',
'signature': self.signature,
'username': '+8618953675221',
'password': '',
'captcha': self.captcha,
'lang': 'en',
'utm_source': '',
'ref_source': 'other_https://www.zhihu.com/signin?next=%2F',
}
headers = {
'x-zse-83': '3_2.0',
'content-type': 'application/x-www-form-urlencoded',
'user-agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.98 Safari/537.36 LBBROWSER',
}
data = urlencode(data)
with open('zhih.js', 'rt', encoding='utf-8') as f:
js = execjs.compile(f.read(), cwd='node_modules')
data = js.call('b', data)
r = self.session.post(url=self.login_api, headers=headers, data=data)
print(r.text)
if r.status_code == 201:
self.session.cookies.save('mycookie')
print('登录成功')
else:
print('登录失败')
def login(self):
self.get_base_cookie()
self.deal_captcha()
self.get_signature()
self.post_login_data()
if __name__ == '__main__':
zhihu_spider = Spider()
zhihu_spider.login()
27 爬虫的反爬措施总结
1 user-agent
2 referer
3 cookie(cookie池，先访问一次)
4 频率限制(代理池，延迟)
5 js加密(扣出来，exjs模块指向)
6 css加密
7 验证码(打码平台)，半手动
8 图片懒加载
拓展
宝塔：
https://github.com/aaPanel/BaoTa/
jumpserver:
https://github.com/jumpserver/jumpserver/
聊天机器人：
https://www.cnblogs.com/liuqingzheng/articles/9079192.html
http：
https://juejin.im/post/6857287743966281736
https://www.cnblogs.com/PythonLearner/p/13424051.html
web服务端给浏览器发信息
# 轮询和长轮询
# websocket：channles(django作者写的)