scrapy分页抓取网页
scrapy分页抓取网页(2.3、Getamp常见的请求方法有两种(组图))
网站优化 • 优采云 发表了文章 • 0 个评论 • 299 次浏览 • 2022-02-18 09:07
scrapy分页抓取网页(2.3、Getamp常见的请求方法有两种(组图))
HTTPS 的安全基础是 SSL，所以通过它传输的内容是经过 SSL 加密的。它的主要功能可以分为两种。
2.3、获取并发布
有两种常见的请求方法：GET 和 POST。
直接在浏览器中输入URL回车，发起GET请求，请求的参数会直接收录在URL中。比如在百度搜索Python，这是一个GET请求，链接为/s?wd=Python，其中url收录请求的参数信息，其中参数wd代表要搜索的关键字。 GET 请求正文为空。 POST 请求主要是在提交表单时发出的。比如登录表单，输入用户名和密码后，点击“登录”按钮，一般会发起POST请求，数据一般以表单的形式传输，不体现在URL中。
GET 和 POST 请求方法有以下区别。
一般来说，登录时需要提交用户名和密码，其中收录敏感信息。如果使用 GET 方式请求，会在 URL 中暴露密码，导致密码泄露，所以最好通过 POST 发送。上传文件时，由于文件内容比较大，也使用POST方式。
2.4、爬虫定义
简单来说，爬虫是一个自动程序，它获取网页并提取和保存信息。
最关键的部分是构造一个请求并将其发送到服务器，然后接收并解析响应。
2.5、会话和 Cookie
HTTP的无状态意味着HTTP协议没有用于事务处理的内存能力，这意味着服务器不知道客户端处于什么状态。当我们向服务器发送请求时，服务器会解析请求，然后返回相应的响应。服务器负责完成这个过程，这个过程是完全独立的。服务器不会记录前后状态的变化，即缺少状态记录。这意味着如果前面的信息需要在后面进行处理，就必须重传，这就导致需要通过一些额外的前面的重复请求才能获得后续的响应，但是这样的效果显然不是我们想要的。为了保持前后的状态，千万不能把之前所有的请求都重传一次，这样太浪费资源了，对于这种需要用户登录的页面更是难上加难。
有两种技术可用于维护 HTTP 连接的状态，会话和 cookie。 session在服务端，即网站的服务端，用来保存用户的session信息；客户端的cookies也可以理解为浏览器端。使用 cookie，浏览器会自动将其附加到下一页访问。发送到服务器后，服务器通过识别Cookies来识别用户，进而判断用户是否处于登录状态，然后返回相应的响应。
我们可以理解，登录凭据存储在 cookie 中。有了它，您只需在下一次请求中发送带有cookies的请求，无需重新输入用户名、密码等信息再次登录。
2.5.1、常见误区
在谈论会话机制时会听到一个常见的误解 - “一旦关闭浏览器，会话就会消失”。想象一下会员卡的例子。除非顾客主动要求店家注销卡，否则店家绝不会轻易删除顾客的资料。会话也是如此，除非程序告诉服务器删除会话，否则服务器会保留它。比如我们在进行注销操作时，程序一般会删除会话。
但是当我们关闭浏览器时，浏览器并没有在关闭前主动通知服务器即将关闭，所以服务器根本没有机会知道浏览器已经关闭。产生这种错觉的原因是大部分会话机制使用会话cookie来保存会话ID信息，而cookie在关闭浏览器后消失。再次连接服务器时，找不到原来的会话。如果服务器设置的cookies保存到硬盘，或者浏览器发送的HTTP请求头通过某种方式被改写，将原来的cookies发送给服务器，那么可以再次打开浏览器，原来的会话ID仍然可以找到，仍然可以维护。登录状态。
而正是因为关闭浏览器不会导致会话被删除，这就需要服务器为会话设置一个过期时间。当自客户端上次使用会话以来的时间超过此过期时间时，服务器可以考虑在活动停止时删除客户端会话以节省存储空间。
3、基本操作
# 普通 GET 请求
response = urllib.request.urlopen('https://www.python.org')
print(response.read().decode('utf-8'))
# POST 请求
# 这里我们传递了一个参数 word, 值是 hello, 它需要被转码成 bytes（字节流）类型
# 而转字节流采用了 bytes 方法，该方法的第一个参数需要是 str（字符串）类型
data = bytes(urllib.parse.urlencode({'word' : 'hello'}), encoding ＝ 'utf8')
# 还有 timeout 设置超时参数
# cafile 和 capath 这两个参数分别指定 CA 证书和它的路径
response = urllib.request.urlopen('http://httpbin.org/post', data = data)
# request 更多的控制参数
# headers 参数通常是设置 User-Agent 来伪装浏览器
# method 代表 GET、POST 等
urllib.request.Request(url, data=None, headers={}, origin_req_host=None, unverifiable=False, method=None)
3.1、高级操作
# urllib.request 模块里的 BaseHandler 类可以处理 Cookies 等高级操作
# 比如下图的需要身份验证
from urllib.request import HTTPPasswordMgrWithDefaultRealm, HTTPBasicAuthHandler, build_opener
from urllib.error import URLError
username = username
password = 'password'
url = 'http://localhost:5000/'
p = HTTPPasswordMgrWithDefaultRealm()
p.add_password(None, url, username, password)
auth_handler = HTTPBasicAuthHandler(p)
opener = build_opener(auth_handler)
try:
result = opener.open(url)
html = result.read().decode('utf8')
print(html)
except URLError as e:
print(e.reason)
# 设置代理
proxy_handler = ProxyHandler({
'http' : 'http://127.0.0.1:9743',
'https': 'https://127.0.0.1:9743'
})
opener = build_opener(proxy_handler)
# 设置 Cookies
cookie = http.cookiejar.CookieJar()
handler = urllib.request.HTTPCookieProcessor(cookie)
opener = urllib.request.build_opener(handler)
response = opener.open('http://www.baidu.com')
# request 库设置 Cookies，request 库可以直接把 Cookie 参数放到 headers 里
r = requests.get('https://www.baidu.com')
# 从中可以看出 Cookie 的类型
print(r.cookies)
for key, value in r.cookies.items():
print(key + '=' + value)
# urlparse() 可以实现 URL 的识别和分段
# quote() 可以将中文字符串转化为 URL 编码
# 对应 unquote() 就是反过来
# 身份验证
r = requests.get('http://localhost:5000', auth＝('username', 'password'))
3.1.1、处理二进制数据
# 下载文件
import requests
r = requests.get('https://github.com/favicon.ic'）
with open('favicon.ico', 'wb') as f:
f.write(r.content)
# 上传文件
files = {'file' : open('favicon.ico', 'rb')}
r = requests.post('http://httpbin.org/post', files=files)
3.2、机器人协议
Robots 协议也称为爬虫协议和机器人协议。它的全称是Robots Exclusion Protocol，用于告诉爬虫和搜索引擎哪些页面可以爬取，哪些页面不能爬取。它通常是一个名为 robots.txt 的文本文件，通常放在 网站 的根目录下。
搜索爬虫访问网站时，首先会检查网站根目录下是否有robots.txt文件。如果存在，搜索爬虫将根据其中定义的爬取范围进行爬取。如果没有找到该文件，搜索爬虫将访问所有可直接访问的页面。
User-agent: *
Disallow: /
Allow: /public/
上述案例的文件内容表示所有搜索爬虫只允许爬取公共目录。
User-agent用于设置爬虫的名称，*表示适用于所有。
disallow代表不能爬取的目录，/代表禁止爬取所有页面。
# 传入 robots.txt 文件的链接即可解析
urllib.robotparser.RobotFileParser(url='')
print(rp.can_fetch('*', 'http://www.jianshu.com/p/b67554025d7d'))
3.3、会话维护
在请求中，如果直接使用get或post等方法，确实可以模拟网页请求，但这实际上相当于不同的会话，也就是说你使用两个浏览器打开不同的页面。
想象这样一个场景，第一次请求使用post方法登录某个网站，第二次登录成功后想获取自己的个人信息，再次使用get方法请求个人信息页面。其实这相当于打开了两个浏览器，两个完全不相关的会话。能否成功获取个人信息？当然不是。
你们中的一些人可能说过我可以为两个请求设置相同的 cookie，对吧？是的，但是这样做很麻烦，而且我们有一个更简单的解决方案。
其实这个问题的主要解决方案是保持同一个会话，相当于打开一个新的浏览器标签而不是打开一个新的浏览器。但是我不想每次都设置cookies，我该怎么办？这时候就有了新的武器——Session对象。
s = requests.Session()
s.get('http://httpbin.org/cookies/set ... %2339;)
r = s.get('http://httpbin.org/cookies')
3.4、使用代理
对于一些网站，在测试过程中多次请求后可以正常获取内容。但是一旦开始大规模爬取，对于大规模频繁的请求，网站可能会弹出验证码，或者跳转到登录认证页面，甚至直接屏蔽客户端IP，造成一定的周期的时间。内部无法访问。
import requests
proxies = {
"http" : "http://10.10.1.10:3128",
"https" : "http://10.10.1.10:1080",
}
requests.get("https://www.taobao.com", proxies=proxies)
4、动态渲染数据爬取
有时当我们抓取带有请求的页面时，结果可能与我们在浏览器中看到的不同：
在浏览器中可以看到页面数据正常显示，但是使用requests得到的结果却不是。这是因为请求都是原创的 HTML 文档，而浏览器中的页面是通过 JavaScript 处理数据的结果。这些数据有多种来源，可以通过 Ajax 加载或收录在 HTML 中。在文档中，也可能是由 JavaScript 和特定算法生成的。
对于第一种情况，数据加载是一种异步加载方式。最初的页面不会收录一些数据。原创页面加载完成后，会向服务器请求一个接口获取数据，然后再加载数据。处理并渲染到网页，其实就是发送一个ajax请求。
根据Web的发展趋势，这种形式的页面越来越多。网页的原创HTML文档不收录任何数据，数据通过Ajax统一加载后显示，这样在Web开发中可以分离前后端，以及服务器带来的压力减少直接渲染页面。
所以遇到这样的页面，直接使用requests等库抓取原创页面是无法获取有效数据的。这时候就需要分析网页后端向接口发送的Ajax请求了。如果可以使用requests来模拟ajax请求，那么就可以成功爬取了。
4.1、Ajax 定义
Ajax，全称是Asynchronous JavaScript and XML，即异步JavaScript XML，它不是一种编程语言，而是使用JavaScript与服务器交换数据，更新一些网页而不刷新页面和页面链接不变。技术。
对于一个传统的网页，如果要更新它的内容，就必须刷新整个页面，但是使用Ajax，你可以在不刷新整个页面的情况下更新页面的内容。在这个过程中，页面实际上是在后台与服务器交互的。获取到数据后，通过JavaScript来改变网页，从而更新网页的内容。
4.2、Ajax 数据抓取
向网页更新发送Ajax请求的过程可以分为以下几个步骤：
1、发送请求
2、解析内容
3、渲染网页
通过开发者模式找到类型为XHR的请求，查看请求的url和请求体，并进行模拟。
并非所有页面都可以通过分析 Ajax 进行爬取。有些页面的参数比较复杂，可能收录加密密钥。很难自己构造参数。
通过直接模拟浏览器操作，无需关注这些界面参数。
4.3、页面动态渲染
但是，javaScript 动态呈现的页面并不局限于 Ajax。有些网页的分页部分是由 JavaScript 生成的，而不是原创的 HTML 代码，不收录 Ajax 请求。比如ECharts的官方实例，它的图形都是JavaScript计算后生成的。
为了解决这些问题，我们可以直接使用模拟浏览器操作的方式，这样就可以看到浏览器里面有什么，抓取到什么源码，也就是什么时候可以抓取它是可见的。 这样，我们就不再需要关心网页内部的 JavaScript 使用什么算法来渲染页面，也不需要关心网页后台的 Ajax 接口的参数。 查看全部
HTTPS 的安全基础是 SSL，所以通过它传输的内容是经过 SSL 加密的。它的主要功能可以分为两种。
2.3、获取并发布
有两种常见的请求方法：GET 和 POST。
直接在浏览器中输入URL回车，发起GET请求，请求的参数会直接收录在URL中。比如在百度搜索Python，这是一个GET请求，链接为/s?wd=Python，其中url收录请求的参数信息，其中参数wd代表要搜索的关键字。 GET 请求正文为空。 POST 请求主要是在提交表单时发出的。比如登录表单，输入用户名和密码后，点击“登录”按钮，一般会发起POST请求，数据一般以表单的形式传输，不体现在URL中。
GET 和 POST 请求方法有以下区别。
一般来说，登录时需要提交用户名和密码，其中收录敏感信息。如果使用 GET 方式请求，会在 URL 中暴露密码，导致密码泄露，所以最好通过 POST 发送。上传文件时，由于文件内容比较大，也使用POST方式。
2.4、爬虫定义
简单来说，爬虫是一个自动程序，它获取网页并提取和保存信息。
最关键的部分是构造一个请求并将其发送到服务器，然后接收并解析响应。
2.5、会话和 Cookie
HTTP的无状态意味着HTTP协议没有用于事务处理的内存能力，这意味着服务器不知道客户端处于什么状态。当我们向服务器发送请求时，服务器会解析请求，然后返回相应的响应。服务器负责完成这个过程，这个过程是完全独立的。服务器不会记录前后状态的变化，即缺少状态记录。这意味着如果前面的信息需要在后面进行处理，就必须重传，这就导致需要通过一些额外的前面的重复请求才能获得后续的响应，但是这样的效果显然不是我们想要的。为了保持前后的状态，千万不能把之前所有的请求都重传一次，这样太浪费资源了，对于这种需要用户登录的页面更是难上加难。
有两种技术可用于维护 HTTP 连接的状态，会话和 cookie。 session在服务端，即网站的服务端，用来保存用户的session信息；客户端的cookies也可以理解为浏览器端。使用 cookie，浏览器会自动将其附加到下一页访问。发送到服务器后，服务器通过识别Cookies来识别用户，进而判断用户是否处于登录状态，然后返回相应的响应。
我们可以理解，登录凭据存储在 cookie 中。有了它，您只需在下一次请求中发送带有cookies的请求，无需重新输入用户名、密码等信息再次登录。
2.5.1、常见误区
在谈论会话机制时会听到一个常见的误解 - “一旦关闭浏览器，会话就会消失”。想象一下会员卡的例子。除非顾客主动要求店家注销卡，否则店家绝不会轻易删除顾客的资料。会话也是如此，除非程序告诉服务器删除会话，否则服务器会保留它。比如我们在进行注销操作时，程序一般会删除会话。
但是当我们关闭浏览器时，浏览器并没有在关闭前主动通知服务器即将关闭，所以服务器根本没有机会知道浏览器已经关闭。产生这种错觉的原因是大部分会话机制使用会话cookie来保存会话ID信息，而cookie在关闭浏览器后消失。再次连接服务器时，找不到原来的会话。如果服务器设置的cookies保存到硬盘，或者浏览器发送的HTTP请求头通过某种方式被改写，将原来的cookies发送给服务器，那么可以再次打开浏览器，原来的会话ID仍然可以找到，仍然可以维护。登录状态。
而正是因为关闭浏览器不会导致会话被删除，这就需要服务器为会话设置一个过期时间。当自客户端上次使用会话以来的时间超过此过期时间时，服务器可以考虑在活动停止时删除客户端会话以节省存储空间。
3、基本操作
# 普通 GET 请求
response = urllib.request.urlopen('https://www.python.org')
print(response.read().decode('utf-8'))
# POST 请求
# 这里我们传递了一个参数 word, 值是 hello, 它需要被转码成 bytes（字节流）类型
# 而转字节流采用了 bytes 方法，该方法的第一个参数需要是 str（字符串）类型
data = bytes(urllib.parse.urlencode({'word' : 'hello'}), encoding ＝ 'utf8')
# 还有 timeout 设置超时参数
# cafile 和 capath 这两个参数分别指定 CA 证书和它的路径
response = urllib.request.urlopen('http://httpbin.org/post', data = data)
# request 更多的控制参数
# headers 参数通常是设置 User-Agent 来伪装浏览器
# method 代表 GET、POST 等
urllib.request.Request(url, data=None, headers={}, origin_req_host=None, unverifiable=False, method=None)
3.1、高级操作
# urllib.request 模块里的 BaseHandler 类可以处理 Cookies 等高级操作
# 比如下图的需要身份验证
from urllib.request import HTTPPasswordMgrWithDefaultRealm, HTTPBasicAuthHandler, build_opener
from urllib.error import URLError
username = username
password = 'password'
url = 'http://localhost:5000/'
p = HTTPPasswordMgrWithDefaultRealm()
p.add_password(None, url, username, password)
auth_handler = HTTPBasicAuthHandler(p)
opener = build_opener(auth_handler)
try:
result = opener.open(url)
html = result.read().decode('utf8')
print(html)
except URLError as e:
print(e.reason)
# 设置代理
proxy_handler = ProxyHandler({
'http' : 'http://127.0.0.1:9743',
'https': 'https://127.0.0.1:9743'
})
opener = build_opener(proxy_handler)
# 设置 Cookies
cookie = http.cookiejar.CookieJar()
handler = urllib.request.HTTPCookieProcessor(cookie)
opener = urllib.request.build_opener(handler)
response = opener.open('http://www.baidu.com')
# request 库设置 Cookies，request 库可以直接把 Cookie 参数放到 headers 里
r = requests.get('https://www.baidu.com')
# 从中可以看出 Cookie 的类型
print(r.cookies)
for key, value in r.cookies.items():
print(key + '=' + value)
# urlparse() 可以实现 URL 的识别和分段
# quote() 可以将中文字符串转化为 URL 编码
# 对应 unquote() 就是反过来
# 身份验证
r = requests.get('http://localhost:5000', auth＝('username', 'password'))
3.1.1、处理二进制数据
# 下载文件
import requests
r = requests.get('https://github.com/favicon.ic'）
with open('favicon.ico', 'wb') as f:
f.write(r.content)
# 上传文件
files = {'file' : open('favicon.ico', 'rb')}
r = requests.post('http://httpbin.org/post', files=files)
3.2、机器人协议
Robots 协议也称为爬虫协议和机器人协议。它的全称是Robots Exclusion Protocol，用于告诉爬虫和搜索引擎哪些页面可以爬取，哪些页面不能爬取。它通常是一个名为 robots.txt 的文本文件，通常放在 网站 的根目录下。
搜索爬虫访问网站时，首先会检查网站根目录下是否有robots.txt文件。如果存在，搜索爬虫将根据其中定义的爬取范围进行爬取。如果没有找到该文件，搜索爬虫将访问所有可直接访问的页面。
User-agent: *
Disallow: /
Allow: /public/
上述案例的文件内容表示所有搜索爬虫只允许爬取公共目录。
User-agent用于设置爬虫的名称，*表示适用于所有。
disallow代表不能爬取的目录，/代表禁止爬取所有页面。
# 传入 robots.txt 文件的链接即可解析
urllib.robotparser.RobotFileParser(url='')
print(rp.can_fetch('*', 'http://www.jianshu.com/p/b67554025d7d'))
3.3、会话维护
在请求中，如果直接使用get或post等方法，确实可以模拟网页请求，但这实际上相当于不同的会话，也就是说你使用两个浏览器打开不同的页面。
想象这样一个场景，第一次请求使用post方法登录某个网站，第二次登录成功后想获取自己的个人信息，再次使用get方法请求个人信息页面。其实这相当于打开了两个浏览器，两个完全不相关的会话。能否成功获取个人信息？当然不是。
你们中的一些人可能说过我可以为两个请求设置相同的 cookie，对吧？是的，但是这样做很麻烦，而且我们有一个更简单的解决方案。
其实这个问题的主要解决方案是保持同一个会话，相当于打开一个新的浏览器标签而不是打开一个新的浏览器。但是我不想每次都设置cookies，我该怎么办？这时候就有了新的武器——Session对象。
s = requests.Session()
s.get('http://httpbin.org/cookies/set ... %2339;)
r = s.get('http://httpbin.org/cookies')
3.4、使用代理
对于一些网站，在测试过程中多次请求后可以正常获取内容。但是一旦开始大规模爬取，对于大规模频繁的请求，网站可能会弹出验证码，或者跳转到登录认证页面，甚至直接屏蔽客户端IP，造成一定的周期的时间。内部无法访问。
import requests
proxies = {
"http" : "http://10.10.1.10:3128",
"https" : "http://10.10.1.10:1080",
}
requests.get("https://www.taobao.com", proxies=proxies)
4、动态渲染数据爬取
有时当我们抓取带有请求的页面时，结果可能与我们在浏览器中看到的不同：
在浏览器中可以看到页面数据正常显示，但是使用requests得到的结果却不是。这是因为请求都是原创的 HTML 文档，而浏览器中的页面是通过 JavaScript 处理数据的结果。这些数据有多种来源，可以通过 Ajax 加载或收录在 HTML 中。在文档中，也可能是由 JavaScript 和特定算法生成的。
对于第一种情况，数据加载是一种异步加载方式。最初的页面不会收录一些数据。原创页面加载完成后，会向服务器请求一个接口获取数据，然后再加载数据。处理并渲染到网页，其实就是发送一个ajax请求。
根据Web的发展趋势，这种形式的页面越来越多。网页的原创HTML文档不收录任何数据，数据通过Ajax统一加载后显示，这样在Web开发中可以分离前后端，以及服务器带来的压力减少直接渲染页面。
所以遇到这样的页面，直接使用requests等库抓取原创页面是无法获取有效数据的。这时候就需要分析网页后端向接口发送的Ajax请求了。如果可以使用requests来模拟ajax请求，那么就可以成功爬取了。
4.1、Ajax 定义
Ajax，全称是Asynchronous JavaScript and XML，即异步JavaScript XML，它不是一种编程语言，而是使用JavaScript与服务器交换数据，更新一些网页而不刷新页面和页面链接不变。技术。
对于一个传统的网页，如果要更新它的内容，就必须刷新整个页面，但是使用Ajax，你可以在不刷新整个页面的情况下更新页面的内容。在这个过程中，页面实际上是在后台与服务器交互的。获取到数据后，通过JavaScript来改变网页，从而更新网页的内容。
4.2、Ajax 数据抓取
向网页更新发送Ajax请求的过程可以分为以下几个步骤：
1、发送请求
2、解析内容
3、渲染网页
通过开发者模式找到类型为XHR的请求，查看请求的url和请求体，并进行模拟。
并非所有页面都可以通过分析 Ajax 进行爬取。有些页面的参数比较复杂，可能收录加密密钥。很难自己构造参数。
通过直接模拟浏览器操作，无需关注这些界面参数。
4.3、页面动态渲染
但是，javaScript 动态呈现的页面并不局限于 Ajax。有些网页的分页部分是由 JavaScript 生成的，而不是原创的 HTML 代码，不收录 Ajax 请求。比如ECharts的官方实例，它的图形都是JavaScript计算后生成的。
为了解决这些问题，我们可以直接使用模拟浏览器操作的方式，这样就可以看到浏览器里面有什么，抓取到什么源码，也就是什么时候可以抓取它是可见的。 这样，我们就不再需要关心网页内部的 JavaScript 使用什么算法来渲染页面，也不需要关心网页后台的 Ajax 接口的参数。 查看全部
scrapy分页抓取网页(2.3、Getamp常见的请求方法有两种(组图))
HTTPS 的安全基础是 SSL，所以通过它传输的内容是经过 SSL 加密的。它的主要功能可以分为两种。
2.3、获取并发布
有两种常见的请求方法：GET 和 POST。
直接在浏览器中输入URL回车，发起GET请求，请求的参数会直接收录在URL中。比如在百度搜索Python，这是一个GET请求，链接为/s?wd=Python，其中url收录请求的参数信息，其中参数wd代表要搜索的关键字。 GET 请求正文为空。 POST 请求主要是在提交表单时发出的。比如登录表单，输入用户名和密码后，点击“登录”按钮，一般会发起POST请求，数据一般以表单的形式传输，不体现在URL中。
GET 和 POST 请求方法有以下区别。
一般来说，登录时需要提交用户名和密码，其中收录敏感信息。如果使用 GET 方式请求，会在 URL 中暴露密码，导致密码泄露，所以最好通过 POST 发送。上传文件时，由于文件内容比较大，也使用POST方式。
2.4、爬虫定义
简单来说，爬虫是一个自动程序，它获取网页并提取和保存信息。
最关键的部分是构造一个请求并将其发送到服务器，然后接收并解析响应。
2.5、会话和 Cookie
HTTP的无状态意味着HTTP协议没有用于事务处理的内存能力，这意味着服务器不知道客户端处于什么状态。当我们向服务器发送请求时，服务器会解析请求，然后返回相应的响应。服务器负责完成这个过程，这个过程是完全独立的。服务器不会记录前后状态的变化，即缺少状态记录。这意味着如果前面的信息需要在后面进行处理，就必须重传，这就导致需要通过一些额外的前面的重复请求才能获得后续的响应，但是这样的效果显然不是我们想要的。为了保持前后的状态，千万不能把之前所有的请求都重传一次，这样太浪费资源了，对于这种需要用户登录的页面更是难上加难。
有两种技术可用于维护 HTTP 连接的状态，会话和 cookie。 session在服务端，即网站的服务端，用来保存用户的session信息；客户端的cookies也可以理解为浏览器端。使用 cookie，浏览器会自动将其附加到下一页访问。发送到服务器后，服务器通过识别Cookies来识别用户，进而判断用户是否处于登录状态，然后返回相应的响应。
我们可以理解，登录凭据存储在 cookie 中。有了它，您只需在下一次请求中发送带有cookies的请求，无需重新输入用户名、密码等信息再次登录。
2.5.1、常见误区
在谈论会话机制时会听到一个常见的误解 - “一旦关闭浏览器，会话就会消失”。想象一下会员卡的例子。除非顾客主动要求店家注销卡，否则店家绝不会轻易删除顾客的资料。会话也是如此，除非程序告诉服务器删除会话，否则服务器会保留它。比如我们在进行注销操作时，程序一般会删除会话。
但是当我们关闭浏览器时，浏览器并没有在关闭前主动通知服务器即将关闭，所以服务器根本没有机会知道浏览器已经关闭。产生这种错觉的原因是大部分会话机制使用会话cookie来保存会话ID信息，而cookie在关闭浏览器后消失。再次连接服务器时，找不到原来的会话。如果服务器设置的cookies保存到硬盘，或者浏览器发送的HTTP请求头通过某种方式被改写，将原来的cookies发送给服务器，那么可以再次打开浏览器，原来的会话ID仍然可以找到，仍然可以维护。登录状态。
而正是因为关闭浏览器不会导致会话被删除，这就需要服务器为会话设置一个过期时间。当自客户端上次使用会话以来的时间超过此过期时间时，服务器可以考虑在活动停止时删除客户端会话以节省存储空间。
3、基本操作
# 普通 GET 请求
response = urllib.request.urlopen('https://www.python.org')
print(response.read().decode('utf-8'))
# POST 请求
# 这里我们传递了一个参数 word, 值是 hello, 它需要被转码成 bytes（字节流）类型
# 而转字节流采用了 bytes 方法，该方法的第一个参数需要是 str（字符串）类型
data = bytes(urllib.parse.urlencode({'word' : 'hello'}), encoding ＝ 'utf8')
# 还有 timeout 设置超时参数
# cafile 和 capath 这两个参数分别指定 CA 证书和它的路径
response = urllib.request.urlopen('http://httpbin.org/post', data = data)
# request 更多的控制参数
# headers 参数通常是设置 User-Agent 来伪装浏览器
# method 代表 GET、POST 等
urllib.request.Request(url, data=None, headers={}, origin_req_host=None, unverifiable=False, method=None)
3.1、高级操作
# urllib.request 模块里的 BaseHandler 类可以处理 Cookies 等高级操作
# 比如下图的需要身份验证
from urllib.request import HTTPPasswordMgrWithDefaultRealm, HTTPBasicAuthHandler, build_opener
from urllib.error import URLError
username = username
password = 'password'
url = 'http://localhost:5000/'
p = HTTPPasswordMgrWithDefaultRealm()
p.add_password(None, url, username, password)
auth_handler = HTTPBasicAuthHandler(p)
opener = build_opener(auth_handler)
try:
result = opener.open(url)
html = result.read().decode('utf8')
print(html)
except URLError as e:
print(e.reason)
# 设置代理
proxy_handler = ProxyHandler({
'http' : 'http://127.0.0.1:9743',
'https': 'https://127.0.0.1:9743'
})
opener = build_opener(proxy_handler)
# 设置 Cookies
cookie = http.cookiejar.CookieJar()
handler = urllib.request.HTTPCookieProcessor(cookie)
opener = urllib.request.build_opener(handler)
response = opener.open('http://www.baidu.com')
# request 库设置 Cookies，request 库可以直接把 Cookie 参数放到 headers 里
r = requests.get('https://www.baidu.com')
# 从中可以看出 Cookie 的类型
print(r.cookies)
for key, value in r.cookies.items():
print(key + '=' + value)
# urlparse() 可以实现 URL 的识别和分段
# quote() 可以将中文字符串转化为 URL 编码
# 对应 unquote() 就是反过来
# 身份验证
r = requests.get('http://localhost:5000', auth＝('username', 'password'))
3.1.1、处理二进制数据
# 下载文件
import requests
r = requests.get('https://github.com/favicon.ic'）
with open('favicon.ico', 'wb') as f:
f.write(r.content)
# 上传文件
files = {'file' : open('favicon.ico', 'rb')}
r = requests.post('http://httpbin.org/post', files=files)
3.2、机器人协议
Robots 协议也称为爬虫协议和机器人协议。它的全称是Robots Exclusion Protocol，用于告诉爬虫和搜索引擎哪些页面可以爬取，哪些页面不能爬取。它通常是一个名为 robots.txt 的文本文件，通常放在 网站 的根目录下。
搜索爬虫访问网站时，首先会检查网站根目录下是否有robots.txt文件。如果存在，搜索爬虫将根据其中定义的爬取范围进行爬取。如果没有找到该文件，搜索爬虫将访问所有可直接访问的页面。
User-agent: *
Disallow: /
Allow: /public/
上述案例的文件内容表示所有搜索爬虫只允许爬取公共目录。
User-agent用于设置爬虫的名称，*表示适用于所有。
disallow代表不能爬取的目录，/代表禁止爬取所有页面。
# 传入 robots.txt 文件的链接即可解析
urllib.robotparser.RobotFileParser(url='')
print(rp.can_fetch('*', 'http://www.jianshu.com/p/b67554025d7d'))
3.3、会话维护
在请求中，如果直接使用get或post等方法，确实可以模拟网页请求，但这实际上相当于不同的会话，也就是说你使用两个浏览器打开不同的页面。
想象这样一个场景，第一次请求使用post方法登录某个网站，第二次登录成功后想获取自己的个人信息，再次使用get方法请求个人信息页面。其实这相当于打开了两个浏览器，两个完全不相关的会话。能否成功获取个人信息？当然不是。
你们中的一些人可能说过我可以为两个请求设置相同的 cookie，对吧？是的，但是这样做很麻烦，而且我们有一个更简单的解决方案。
其实这个问题的主要解决方案是保持同一个会话，相当于打开一个新的浏览器标签而不是打开一个新的浏览器。但是我不想每次都设置cookies，我该怎么办？这时候就有了新的武器——Session对象。
s = requests.Session()
s.get('http://httpbin.org/cookies/set ... %2339;)
r = s.get('http://httpbin.org/cookies')
3.4、使用代理
对于一些网站，在测试过程中多次请求后可以正常获取内容。但是一旦开始大规模爬取，对于大规模频繁的请求，网站可能会弹出验证码，或者跳转到登录认证页面，甚至直接屏蔽客户端IP，造成一定的周期的时间。内部无法访问。
import requests
proxies = {
"http" : "http://10.10.1.10:3128",
"https" : "http://10.10.1.10:1080",
}
requests.get("https://www.taobao.com", proxies=proxies)
4、动态渲染数据爬取
有时当我们抓取带有请求的页面时，结果可能与我们在浏览器中看到的不同：
在浏览器中可以看到页面数据正常显示，但是使用requests得到的结果却不是。这是因为请求都是原创的 HTML 文档，而浏览器中的页面是通过 JavaScript 处理数据的结果。这些数据有多种来源，可以通过 Ajax 加载或收录在 HTML 中。在文档中，也可能是由 JavaScript 和特定算法生成的。
对于第一种情况，数据加载是一种异步加载方式。最初的页面不会收录一些数据。原创页面加载完成后，会向服务器请求一个接口获取数据，然后再加载数据。处理并渲染到网页，其实就是发送一个ajax请求。
根据Web的发展趋势，这种形式的页面越来越多。网页的原创HTML文档不收录任何数据，数据通过Ajax统一加载后显示，这样在Web开发中可以分离前后端，以及服务器带来的压力减少直接渲染页面。
所以遇到这样的页面，直接使用requests等库抓取原创页面是无法获取有效数据的。这时候就需要分析网页后端向接口发送的Ajax请求了。如果可以使用requests来模拟ajax请求，那么就可以成功爬取了。
4.1、Ajax 定义
Ajax，全称是Asynchronous JavaScript and XML，即异步JavaScript XML，它不是一种编程语言，而是使用JavaScript与服务器交换数据，更新一些网页而不刷新页面和页面链接不变。技术。
对于一个传统的网页，如果要更新它的内容，就必须刷新整个页面，但是使用Ajax，你可以在不刷新整个页面的情况下更新页面的内容。在这个过程中，页面实际上是在后台与服务器交互的。获取到数据后，通过JavaScript来改变网页，从而更新网页的内容。
4.2、Ajax 数据抓取
向网页更新发送Ajax请求的过程可以分为以下几个步骤：
1、发送请求
2、解析内容
3、渲染网页
通过开发者模式找到类型为XHR的请求，查看请求的url和请求体，并进行模拟。
并非所有页面都可以通过分析 Ajax 进行爬取。有些页面的参数比较复杂，可能收录加密密钥。很难自己构造参数。
通过直接模拟浏览器操作，无需关注这些界面参数。
4.3、页面动态渲染
但是，javaScript 动态呈现的页面并不局限于 Ajax。有些网页的分页部分是由 JavaScript 生成的，而不是原创的 HTML 代码，不收录 Ajax 请求。比如ECharts的官方实例，它的图形都是JavaScript计算后生成的。
为了解决这些问题，我们可以直接使用模拟浏览器操作的方式，这样就可以看到浏览器里面有什么，抓取到什么源码，也就是什么时候可以抓取它是可见的。 这样，我们就不再需要关心网页内部的 JavaScript 使用什么算法来渲染页面，也不需要关心网页后台的 Ajax 接口的参数。
scrapy分页抓取网页(环境搭建window系统环境安装AnacondaAnaconda文章目录解析篇)
网站优化 • 优采云 发表了文章 • 0 个评论 • 54 次浏览 • 2022-02-18 09:04
scrapy分页抓取网页(环境搭建window系统环境安装AnacondaAnaconda文章目录解析篇)
介绍
开发环境为 Python3.6, Scrapy 版本2.4.x , Gerapy 版本0.9.x , 所有爬虫项目的index目录
本系列内容作为规范爬虫的指南，为广大爬虫工程师分享爬虫工作经验，用作者自己的经验了解Python3的爬虫工作心得。
Environment 搭建window系统环境
安装 Anaconda
Anaconda 指的是一个开源的 Python 发行版，其中收录 N 多个科学包，例如 Python 和 conda 及其依赖项。简单理解为傻瓜的python包。
蟒蛇下载地址
由于笔者买不起Apple系列电脑，这里以win系统安装为例（Linux必须是图形界面的操作系统，如Ubuntu系统）
打开安装程序后，继续单击下一步。
安装结束，点击关闭，然后打开命令行CMD，出现下图证明安装成功。
安装 Pycharm
社区版 & 专业版 Pycharm 下载地址
下载后根据自己的情况选择压缩包。
在如图所示的位置启动程序。
安装 Scrapy
pip install scrapy==2.4.0
Linux系统环境
以腾讯云的 Centos 7.x 版本为例。其他版本的系统略有不同。如果您有任何安装问题，您可以留言。
Python3安装
'''安装必备包'''
yum groupinstall 'Development Tools'
yum install -y ncurses-libs zlib-devel mysql-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel
yum -y install gcc
'''下载python3.6.5'''
cd /usr/local/
wget https://www.python.org/ftp/pyt ... ar.xz
'''解压'''
tar -xf Python-3.6.5.tar.xz
mkdir python3
mv Python-3.6.5 python3
cd python3/Python-3.6.5
./configure --prefix=/usr/local/python3 --enable-optimizations
make
make altinstall
'''修改软连接'''
ln -s /usr/local/python3/bin/python3.6 /usr/bin/python3
ln -s /usr/local/python3/bin/pip3.6 /usr/bin/pip3
'''删除软连接,如果设置软连接出错使用'''
rm -rf /usr/bin/python3
rm -rf /usr/bin/pip3
'''检查是否安装版本正确'''
python3 --version
安装 Scrapy
pip3 install scrapy==2.4.0
Scrapy爬虫框架
Scrapy，一个用 Python 开发的快速、高级的屏幕抓取和网页抓取框架，用于抓取网站并从页面中提取结构化数据。Scrapy 用途广泛，可用于数据挖掘、监控和自动化测试。
它最初是为页面抓取（更准确地说是网页抓取）而设计的，后台也用于获取API或一般网络爬虫返回的数据。
要了解学习所有 Scrapy 模块，请点击传送门
[scrapy 2.4.0 文章目录]源码分析：所有配置目录索引
数据采集流程概览
调度器：假设它是一个 URL 的优先队列（爬取网页的网站或链接），让它决定下一个要爬取的 URL，同时去除重复的 URL（不做无用的工作）。用户可以根据自己的需要自定义调度器。
下载器（Downloader）：所有组件中最繁重的，它用于在网络上高速下载资源。Scrapy 的下载器代码并不太复杂，但是效率很高。主要原因是Scrapy下载器是建立在twisted的高效异步模型之上的（其实整个框架都是建立在这个模型之上的）。
爬虫（Spider）：用户定制自己的爬虫（通过自定义正则表达式等语法），从特定的网页中提取自己需要的信息，即所谓的实体（Item）。用户还可以从中提取链接，让 Scrapy 继续爬取下一页。
项目管道：用于处理蜘蛛提取的实体。主要功能是持久化实体，验证实体的有效性，清除不必要的信息。
Scrapy引擎（Scrapy Engine）：Scrapy引擎是整个框架的核心。它用于控制调试器、下载器和爬虫。实际上，引擎相当于计算机的CPU，它控制着整个过程。 查看全部
介绍
开发环境为 Python3.6, Scrapy 版本2.4.x , Gerapy 版本0.9.x , 所有爬虫项目的index目录
本系列内容作为规范爬虫的指南，为广大爬虫工程师分享爬虫工作经验，用作者自己的经验了解Python3的爬虫工作心得。
Environment 搭建window系统环境
安装 Anaconda
Anaconda 指的是一个开源的 Python 发行版，其中收录 N 多个科学包，例如 Python 和 conda 及其依赖项。简单理解为傻瓜的python包。
蟒蛇下载地址
由于笔者买不起Apple系列电脑，这里以win系统安装为例（Linux必须是图形界面的操作系统，如Ubuntu系统）
打开安装程序后，继续单击下一步。
安装结束，点击关闭，然后打开命令行CMD，出现下图证明安装成功。
安装 Pycharm
社区版 & 专业版 Pycharm 下载地址
下载后根据自己的情况选择压缩包。
在如图所示的位置启动程序。
安装 Scrapy
pip install scrapy==2.4.0
Linux系统环境
以腾讯云的 Centos 7.x 版本为例。其他版本的系统略有不同。如果您有任何安装问题，您可以留言。
Python3安装
'''安装必备包'''
yum groupinstall 'Development Tools'
yum install -y ncurses-libs zlib-devel mysql-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel
yum -y install gcc
'''下载python3.6.5'''
cd /usr/local/
wget https://www.python.org/ftp/pyt ... ar.xz
'''解压'''
tar -xf Python-3.6.5.tar.xz
mkdir python3
mv Python-3.6.5 python3
cd python3/Python-3.6.5
./configure --prefix=/usr/local/python3 --enable-optimizations
make
make altinstall
'''修改软连接'''
ln -s /usr/local/python3/bin/python3.6 /usr/bin/python3
ln -s /usr/local/python3/bin/pip3.6 /usr/bin/pip3
'''删除软连接,如果设置软连接出错使用'''
rm -rf /usr/bin/python3
rm -rf /usr/bin/pip3
'''检查是否安装版本正确'''
python3 --version
安装 Scrapy
pip3 install scrapy==2.4.0
Scrapy爬虫框架
Scrapy，一个用 Python 开发的快速、高级的屏幕抓取和网页抓取框架，用于抓取网站并从页面中提取结构化数据。Scrapy 用途广泛，可用于数据挖掘、监控和自动化测试。
它最初是为页面抓取（更准确地说是网页抓取）而设计的，后台也用于获取API或一般网络爬虫返回的数据。
要了解学习所有 Scrapy 模块，请点击传送门
[scrapy 2.4.0 文章目录]源码分析：所有配置目录索引
数据采集流程概览
调度器：假设它是一个 URL 的优先队列（爬取网页的网站或链接），让它决定下一个要爬取的 URL，同时去除重复的 URL（不做无用的工作）。用户可以根据自己的需要自定义调度器。
下载器（Downloader）：所有组件中最繁重的，它用于在网络上高速下载资源。Scrapy 的下载器代码并不太复杂，但是效率很高。主要原因是Scrapy下载器是建立在twisted的高效异步模型之上的（其实整个框架都是建立在这个模型之上的）。
爬虫（Spider）：用户定制自己的爬虫（通过自定义正则表达式等语法），从特定的网页中提取自己需要的信息，即所谓的实体（Item）。用户还可以从中提取链接，让 Scrapy 继续爬取下一页。
项目管道：用于处理蜘蛛提取的实体。主要功能是持久化实体，验证实体的有效性，清除不必要的信息。
Scrapy引擎（Scrapy Engine）：Scrapy引擎是整个框架的核心。它用于控制调试器、下载器和爬虫。实际上，引擎相当于计算机的CPU，它控制着整个过程。 查看全部
scrapy分页抓取网页(环境搭建window系统环境安装AnacondaAnaconda文章目录解析篇)
介绍
开发环境为 Python3.6, Scrapy 版本2.4.x , Gerapy 版本0.9.x , 所有爬虫项目的index目录
本系列内容作为规范爬虫的指南，为广大爬虫工程师分享爬虫工作经验，用作者自己的经验了解Python3的爬虫工作心得。
Environment 搭建window系统环境
安装 Anaconda
Anaconda 指的是一个开源的 Python 发行版，其中收录 N 多个科学包，例如 Python 和 conda 及其依赖项。简单理解为傻瓜的python包。
蟒蛇下载地址
由于笔者买不起Apple系列电脑，这里以win系统安装为例（Linux必须是图形界面的操作系统，如Ubuntu系统）
打开安装程序后，继续单击下一步。
安装结束，点击关闭，然后打开命令行CMD，出现下图证明安装成功。
安装 Pycharm
社区版 & 专业版 Pycharm 下载地址
下载后根据自己的情况选择压缩包。
在如图所示的位置启动程序。
安装 Scrapy
pip install scrapy==2.4.0
Linux系统环境
以腾讯云的 Centos 7.x 版本为例。其他版本的系统略有不同。如果您有任何安装问题，您可以留言。
Python3安装
'''安装必备包'''
yum groupinstall 'Development Tools'
yum install -y ncurses-libs zlib-devel mysql-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel
yum -y install gcc
'''下载python3.6.5'''
cd /usr/local/
wget https://www.python.org/ftp/pyt ... ar.xz
'''解压'''
tar -xf Python-3.6.5.tar.xz
mkdir python3
mv Python-3.6.5 python3
cd python3/Python-3.6.5
./configure --prefix=/usr/local/python3 --enable-optimizations
make
make altinstall
'''修改软连接'''
ln -s /usr/local/python3/bin/python3.6 /usr/bin/python3
ln -s /usr/local/python3/bin/pip3.6 /usr/bin/pip3
'''删除软连接,如果设置软连接出错使用'''
rm -rf /usr/bin/python3
rm -rf /usr/bin/pip3
'''检查是否安装版本正确'''
python3 --version
安装 Scrapy
pip3 install scrapy==2.4.0
Scrapy爬虫框架
Scrapy，一个用 Python 开发的快速、高级的屏幕抓取和网页抓取框架，用于抓取网站并从页面中提取结构化数据。Scrapy 用途广泛，可用于数据挖掘、监控和自动化测试。
它最初是为页面抓取（更准确地说是网页抓取）而设计的，后台也用于获取API或一般网络爬虫返回的数据。
要了解学习所有 Scrapy 模块，请点击传送门
[scrapy 2.4.0 文章目录]源码分析：所有配置目录索引
数据采集流程概览
调度器：假设它是一个 URL 的优先队列（爬取网页的网站或链接），让它决定下一个要爬取的 URL，同时去除重复的 URL（不做无用的工作）。用户可以根据自己的需要自定义调度器。
下载器（Downloader）：所有组件中最繁重的，它用于在网络上高速下载资源。Scrapy 的下载器代码并不太复杂，但是效率很高。主要原因是Scrapy下载器是建立在twisted的高效异步模型之上的（其实整个框架都是建立在这个模型之上的）。
爬虫（Spider）：用户定制自己的爬虫（通过自定义正则表达式等语法），从特定的网页中提取自己需要的信息，即所谓的实体（Item）。用户还可以从中提取链接，让 Scrapy 继续爬取下一页。
项目管道：用于处理蜘蛛提取的实体。主要功能是持久化实体，验证实体的有效性，清除不必要的信息。
Scrapy引擎（Scrapy Engine）：Scrapy引擎是整个框架的核心。它用于控制调试器、下载器和爬虫。实际上，引擎相当于计算机的CPU，它控制着整个过程。
scrapy分页抓取网页(如何在scrapy爬虫框架中创建网页节点-scrapy框架初体验)
网站优化 • 优采云 发表了文章 • 0 个评论 • 65 次浏览 • 2022-02-18 05:03
scrapy分页抓取网页(如何在scrapy爬虫框架中创建网页节点-scrapy框架初体验)
scrapy分页抓取网页节点发现自己要抓取的json序列化数据-scrapy。models。request利用python爬虫框架：python3。6参考文章：如何在scrapy爬虫框架中创建网页节点-scrapy爬虫框架初体验scrapypython爬虫框架初体验-用一条命令抓取一页信息请求对应链接-用一条命令抓取一页信息读取对应链接并分页。
如果是在excel中导入爬虫数据的话，需要excel转html，然后导入scrapy。
excel>data.txt>text
如果只是放一行的话，html是有文本格式，把文本格式的txt中保存为scrapy里的变量就行。
fromscrapy。fieldimportfieldfield(writer='field')localwriter_obj=[xforxinfield(writer_obj)]。valueifxinscrapy。field。value:returnxfield(writer='item')data=field(forfieldindata)data。replace('item','itemgroup')。
scrapy-request
用java做爬虫？那样找一个本地的页面文件，然后存下来。我刚学scrapy用python爬取，然后把那个页面存到一个json文件。
做成html文件
到excel里查找
如果你本地已经存有spiders的话，去找你要爬取的spider，ctrl+r它就有个excelxml的文件，如果没有， 查看全部
scrapy分页抓取网页节点发现自己要抓取的json序列化数据-scrapy。models。request利用python爬虫框架：python3。6参考文章：如何在scrapy爬虫框架中创建网页节点-scrapy爬虫框架初体验scrapypython爬虫框架初体验-用一条命令抓取一页信息请求对应链接-用一条命令抓取一页信息读取对应链接并分页。
如果是在excel中导入爬虫数据的话，需要excel转html，然后导入scrapy。
excel>data.txt>text
如果只是放一行的话，html是有文本格式，把文本格式的txt中保存为scrapy里的变量就行。
fromscrapy。fieldimportfieldfield(writer='field')localwriter_obj=[xforxinfield(writer_obj)]。valueifxinscrapy。field。value:returnxfield(writer='item')data=field(forfieldindata)data。replace('item','itemgroup')。
scrapy-request
用java做爬虫？那样找一个本地的页面文件，然后存下来。我刚学scrapy用python爬取，然后把那个页面存到一个json文件。
做成html文件
到excel里查找
如果你本地已经存有spiders的话，去找你要爬取的spider，ctrl+r它就有个excelxml的文件，如果没有， 查看全部
scrapy分页抓取网页(如何在scrapy爬虫框架中创建网页节点-scrapy框架初体验)
scrapy分页抓取网页节点发现自己要抓取的json序列化数据-scrapy。models。request利用python爬虫框架：python3。6参考文章：如何在scrapy爬虫框架中创建网页节点-scrapy爬虫框架初体验scrapypython爬虫框架初体验-用一条命令抓取一页信息请求对应链接-用一条命令抓取一页信息读取对应链接并分页。
如果是在excel中导入爬虫数据的话，需要excel转html，然后导入scrapy。
excel>data.txt>text
如果只是放一行的话，html是有文本格式，把文本格式的txt中保存为scrapy里的变量就行。
fromscrapy。fieldimportfieldfield(writer='field')localwriter_obj=[xforxinfield(writer_obj)]。valueifxinscrapy。field。value:returnxfield(writer='item')data=field(forfieldindata)data。replace('item','itemgroup')。
scrapy-request
用java做爬虫？那样找一个本地的页面文件，然后存下来。我刚学scrapy用python爬取，然后把那个页面存到一个json文件。
做成html文件
到excel里查找
如果你本地已经存有spiders的话，去找你要爬取的spider，ctrl+r它就有个excelxml的文件，如果没有，
scrapy分页抓取网页(scrapy表达式先用python3天：干货教程|爬虫一小时系列教程)
网站优化 • 优采云 发表了文章 • 0 个评论 • 62 次浏览 • 2022-02-17 11:01
scrapy分页抓取网页(scrapy表达式先用python3天：干货教程|爬虫一小时系列教程)
scrapy分页抓取网页我们的爬虫需要发起多次请求，并从每一次请求中获取数据，而这样就导致不方便爬取分页页面。在capy中把整个爬虫分为多个子爬虫。pipinstallgenscrapy安装完genscrapy后再次pipinstallscrapy==2.3.1我们可以这样写爬虫scrapygenscrapygenscrapy=genscrapy.spider(spider_name='org.doubanmara_demo',start_urls=spider_name,spider_end_urls=spider_end_urls,state=spider_state,url_pattern='/',allowed_headers={'x-requested-with':'xmlhttprequest'})1，抓取第一页爬取整个项目3，爬取最后一页。
转化为正则表达式
先用python爬虫3天：干货教程|爬虫一小时系列教程-allc/_第二步：将数据分析分割成两个目录：/vendor/id/temp.xml文件和/vendor/id/list.xml文件，其中/vendor/id/temp.xml文件中抓取的数据写入request对象中，/vendor/id/list.xml中的数据写入list对象中。
直接用scrapy是http请求出来的数据.分页与否要看具体模块和具体实现
googlenextstep/scrapy，第二步就分页了。
scrapy3
直接返回/vendor/id/temp.xmlvia第二页到/vendor/id/list.xml 查看全部
scrapy分页抓取网页我们的爬虫需要发起多次请求，并从每一次请求中获取数据，而这样就导致不方便爬取分页页面。在capy中把整个爬虫分为多个子爬虫。pipinstallgenscrapy安装完genscrapy后再次pipinstallscrapy==2.3.1我们可以这样写爬虫scrapygenscrapygenscrapy=genscrapy.spider(spider_name='org.doubanmara_demo',start_urls=spider_name,spider_end_urls=spider_end_urls,state=spider_state,url_pattern='/',allowed_headers={'x-requested-with':'xmlhttprequest'})1，抓取第一页爬取整个项目3，爬取最后一页。
转化为正则表达式
先用python爬虫3天：干货教程|爬虫一小时系列教程-allc/_第二步：将数据分析分割成两个目录：/vendor/id/temp.xml文件和/vendor/id/list.xml文件，其中/vendor/id/temp.xml文件中抓取的数据写入request对象中，/vendor/id/list.xml中的数据写入list对象中。
直接用scrapy是http请求出来的数据.分页与否要看具体模块和具体实现
googlenextstep/scrapy，第二步就分页了。
scrapy3
直接返回/vendor/id/temp.xmlvia第二页到/vendor/id/list.xml 查看全部
scrapy分页抓取网页(scrapy表达式先用python3天：干货教程|爬虫一小时系列教程)
scrapy分页抓取网页我们的爬虫需要发起多次请求，并从每一次请求中获取数据，而这样就导致不方便爬取分页页面。在capy中把整个爬虫分为多个子爬虫。pipinstallgenscrapy安装完genscrapy后再次pipinstallscrapy==2.3.1我们可以这样写爬虫scrapygenscrapygenscrapy=genscrapy.spider(spider_name='org.doubanmara_demo',start_urls=spider_name,spider_end_urls=spider_end_urls,state=spider_state,url_pattern='/',allowed_headers={'x-requested-with':'xmlhttprequest'})1，抓取第一页爬取整个项目3，爬取最后一页。
转化为正则表达式
先用python爬虫3天：干货教程|爬虫一小时系列教程-allc/_第二步：将数据分析分割成两个目录：/vendor/id/temp.xml文件和/vendor/id/list.xml文件，其中/vendor/id/temp.xml文件中抓取的数据写入request对象中，/vendor/id/list.xml中的数据写入list对象中。
直接用scrapy是http请求出来的数据.分页与否要看具体模块和具体实现
googlenextstep/scrapy，第二步就分页了。
scrapy3
直接返回/vendor/id/temp.xmlvia第二页到/vendor/id/list.xml
scrapy分页抓取网页( 一个新网站如何让搜索引擎快速收录?下面西营门小程序)
网站优化 • 优采云 发表了文章 • 0 个评论 • 79 次浏览 • 2022-02-16 17:23
scrapy分页抓取网页(
一个新网站如何让搜索引擎快速收录?下面西营门小程序)
一个新的网站如何让搜索引擎变快收录？下面，盛汇友联就为大家讲解一下如何解决这个问题。
1、网站结构应该便于搜索引擎蜘蛛阅读
目前，搜索引擎蜘蛛只能很好地处理文本内容，而不能读取非文本内容，如Flash、图片等，所以我们应该尽量在文本内容中表达更重要的内容。例如 网站 的导航栏必须使用文本类型的链接。如果使用Flash和图片，可能看起来更漂亮，但对SEO不友好。而对于 网站 用户来说，图片和 Flash 的加载速度很慢。
2、优化网页标记
主要包括页面标题（Title）优化、关键词（关键字）优化和描述（Description）等基本信息。
3、将您自己的网站网址添加到主要搜索引擎
<p>在制作新的网站时，一直希望能尽快被搜索引擎收录，网站被 查看全部
一个新网站如何让搜索引擎快速收录?下面西营门小程序)
一个新的网站如何让搜索引擎变快收录？下面，盛汇友联就为大家讲解一下如何解决这个问题。
1、网站结构应该便于搜索引擎蜘蛛阅读
目前，搜索引擎蜘蛛只能很好地处理文本内容，而不能读取非文本内容，如Flash、图片等，所以我们应该尽量在文本内容中表达更重要的内容。例如 网站 的导航栏必须使用文本类型的链接。如果使用Flash和图片，可能看起来更漂亮，但对SEO不友好。而对于 网站 用户来说，图片和 Flash 的加载速度很慢。
2、优化网页标记
主要包括页面标题（Title）优化、关键词（关键字）优化和描述（Description）等基本信息。
3、将您自己的网站网址添加到主要搜索引擎
<p>在制作新的网站时，一直希望能尽快被搜索引擎收录，网站被 查看全部
scrapy分页抓取网页(
一个新网站如何让搜索引擎快速收录?下面西营门小程序)
一个新的网站如何让搜索引擎变快收录？下面，盛汇友联就为大家讲解一下如何解决这个问题。
1、网站结构应该便于搜索引擎蜘蛛阅读
目前，搜索引擎蜘蛛只能很好地处理文本内容，而不能读取非文本内容，如Flash、图片等，所以我们应该尽量在文本内容中表达更重要的内容。例如 网站 的导航栏必须使用文本类型的链接。如果使用Flash和图片，可能看起来更漂亮，但对SEO不友好。而对于 网站 用户来说，图片和 Flash 的加载速度很慢。
2、优化网页标记
主要包括页面标题（Title）优化、关键词（关键字）优化和描述（Description）等基本信息。
3、将您自己的网站网址添加到主要搜索引擎
<p>在制作新的网站时，一直希望能尽快被搜索引擎收录，网站被
scrapy分页抓取网页(如何抓取目标网站是以Js的方式动态生成数据的网页)
网站优化 • 优采云 发表了文章 • 0 个评论 • 46 次浏览 • 2022-02-12 04:21
scrapy分页抓取网页(如何抓取目标网站是以Js的方式动态生成数据的网页)
我们在爬取数据的时候，如果目标网站是以Js的方式动态生成数据，以滚动页面的方式进行分页，那我们怎么爬取呢？
如今日头条网站：
我们可以使用 Selenium 来做到这一点。虽然 Selenium 是为 Web 应用程序的自动化测试而设计的，但它非常适合数据抓取，可以轻松绕过 网站 的反爬虫限制，因为 Selenium 直接运行在浏览器中，就像真正的用户一样它。
使用Selenium，我们不仅可以爬取Js动态生成数据的网页，还可以爬取通过滚动页面进行分页的网页。
首先，我们使用maven来导入Selenium依赖：
org.seleniumhq.selenium
selenium-java
2.47.1
然后就可以编写代码进行爬取了：
<p>import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import java.util.List;
import java.util.Random;
/**
* 如何抓取Js动态生成数据且以滚动页面方式分页的网页
* 以抓取今日头条为例说明：http://toutiao.com/
* Created by ysc on 10/13/15.
*/
public class Toutiao {
public static void main(String[] args) throws Exception{
//等待数据加载的时间
//为了防止服务器封锁，这里的时间要模拟人的行为，随机且不能太短
long waitLoadBaseTime = 3000;
int waitLoadRandomTime = 3000;
Random random = new Random(System.currentTimeMillis());
//火狐浏览器
WebDriver driver = new FirefoxDriver();
//要抓取的网页
driver.get("http://toutiao.com/");
//等待页面动态加载完毕
Thread.sleep(waitLoadBaseTime+random.nextInt(waitLoadRandomTime));
//要加载多少页数据
int pages=5;
for(int i=0; i 查看全部
我们在爬取数据的时候，如果目标网站是以Js的方式动态生成数据，以滚动页面的方式进行分页，那我们怎么爬取呢？
如今日头条网站：
我们可以使用 Selenium 来做到这一点。虽然 Selenium 是为 Web 应用程序的自动化测试而设计的，但它非常适合数据抓取，可以轻松绕过 网站 的反爬虫限制，因为 Selenium 直接运行在浏览器中，就像真正的用户一样它。
使用Selenium，我们不仅可以爬取Js动态生成数据的网页，还可以爬取通过滚动页面进行分页的网页。
首先，我们使用maven来导入Selenium依赖：
org.seleniumhq.selenium
selenium-java
2.47.1
然后就可以编写代码进行爬取了：
<p>import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import java.util.List;
import java.util.Random;
/**
* 如何抓取Js动态生成数据且以滚动页面方式分页的网页
* 以抓取今日头条为例说明：http://toutiao.com/
* Created by ysc on 10/13/15.
*/
public class Toutiao {
public static void main(String[] args) throws Exception{
//等待数据加载的时间
//为了防止服务器封锁，这里的时间要模拟人的行为，随机且不能太短
long waitLoadBaseTime = 3000;
int waitLoadRandomTime = 3000;
Random random = new Random(System.currentTimeMillis());
//火狐浏览器
WebDriver driver = new FirefoxDriver();
//要抓取的网页
driver.get("http://toutiao.com/");
//等待页面动态加载完毕
Thread.sleep(waitLoadBaseTime+random.nextInt(waitLoadRandomTime));
//要加载多少页数据
int pages=5;
for(int i=0; i 查看全部
scrapy分页抓取网页(如何抓取目标网站是以Js的方式动态生成数据的网页)
我们在爬取数据的时候，如果目标网站是以Js的方式动态生成数据，以滚动页面的方式进行分页，那我们怎么爬取呢？
如今日头条网站：
我们可以使用 Selenium 来做到这一点。虽然 Selenium 是为 Web 应用程序的自动化测试而设计的，但它非常适合数据抓取，可以轻松绕过 网站 的反爬虫限制，因为 Selenium 直接运行在浏览器中，就像真正的用户一样它。
使用Selenium，我们不仅可以爬取Js动态生成数据的网页，还可以爬取通过滚动页面进行分页的网页。
首先，我们使用maven来导入Selenium依赖：
org.seleniumhq.selenium
selenium-java
2.47.1
然后就可以编写代码进行爬取了：
<p>import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import java.util.List;
import java.util.Random;
/**
* 如何抓取Js动态生成数据且以滚动页面方式分页的网页
* 以抓取今日头条为例说明：http://toutiao.com/
* Created by ysc on 10/13/15.
*/
public class Toutiao {
public static void main(String[] args) throws Exception{
//等待数据加载的时间
//为了防止服务器封锁，这里的时间要模拟人的行为，随机且不能太短
long waitLoadBaseTime = 3000;
int waitLoadRandomTime = 3000;
Random random = new Random(System.currentTimeMillis());
//火狐浏览器
WebDriver driver = new FirefoxDriver();
//要抓取的网页
driver.get("http://toutiao.com/";);
//等待页面动态加载完毕
Thread.sleep(waitLoadBaseTime+random.nextInt(waitLoadRandomTime));
//要加载多少页数据
int pages=5;
for(int i=0; i
scrapy分页抓取网页(scrapy分页抓取网页信息实现网络爬虫和抓包分析器-scrapy)
网站优化 • 优采云 发表了文章 • 0 个评论 • 69 次浏览 • 2022-02-11 11:02
scrapy分页抓取网页(scrapy分页抓取网页信息实现网络爬虫和抓包分析器-scrapy)
scrapy分页抓取网页信息实现网络爬虫和抓包分析器-scrapy中文文档-csdn博客-中国最大的it技术社区scrapy是一个开源的pythonweb框架，它提供了一个功能强大的networkapi，可以让爬虫获取网络网页信息和重定向网页从而爬取动态网页。scrapy的核心是用于在scrapyweb框架中创建和利用多线程抓取和分析网页的核心功能。
scrapy通过分层的scrapyweb框架将请求或响应流传递给下游爬虫/job可以进行不同的数据抓取。scrapy支持windows、linux和mac系统。我们分别在mac和windows系统环境下做演示。scrapy分页抓取网页信息实现代码：importscrapyclassglobaljsonitem:name=scrapy.field(scrapy.field())aspnum=scrapy.field(scrapy.field())url=''headers={'user-agent':'mozilla/5.0(windowsnt10.0;win64;x64)applewebkit/537.36(khtml,likegecko)chrome/72.0.3440.137safari/537.36'}referer=scrapy.get(headers=headers)scrapy.request(url=url,post=globaljsonitem,headers=headers)scrapy.items().urlparameter('url',list(request.text))fig=plt.figure()a=fig.add_subplot(2,2,1)name=globaljsonitem(a)aspnum=globaljsonitem(a)url=''url=''partial=globaljsonitem(aspnum)url='"\s+"\s+"\s+"\s+"+"\s+"\s+"\s+"+"\s+"\s+"+"\s+"'content=scrapy.extract_text(url,encoding='utf-8')withopen('test.txt','w+')asfp:fp.write(content)请求进入到后台，content.follow('/')，可以看到，此时请求是从创建爬虫的giteawall.py文件开始抓取下来的，爬虫之后，就可以去掉设置参数/urlname/aspnum这两项，返回第二个session对象。
爬虫对象是一个返回列表并列举着所有已爬取url的web服务器。可以看到url这个数组不包含参数，而web服务器这个函数不是很难的，可以读取文件，referer当然也是用来设置必要参数的。既然是request方法，可以看下响应的处理，item是http请求内容，headers当然是必要参数了，和request是一样的。
//name是giteawall.py的name方法classgiteawall:def__init__(self,name):self.name=nameself.spider。 查看全部
scrapy分页抓取网页信息实现网络爬虫和抓包分析器-scrapy中文文档-csdn博客-中国最大的it技术社区scrapy是一个开源的pythonweb框架，它提供了一个功能强大的networkapi，可以让爬虫获取网络网页信息和重定向网页从而爬取动态网页。scrapy的核心是用于在scrapyweb框架中创建和利用多线程抓取和分析网页的核心功能。
scrapy通过分层的scrapyweb框架将请求或响应流传递给下游爬虫/job可以进行不同的数据抓取。scrapy支持windows、linux和mac系统。我们分别在mac和windows系统环境下做演示。scrapy分页抓取网页信息实现代码：importscrapyclassglobaljsonitem:name=scrapy.field(scrapy.field())aspnum=scrapy.field(scrapy.field())url=''headers={'user-agent':'mozilla/5.0(windowsnt10.0;win64;x64)applewebkit/537.36(khtml,likegecko)chrome/72.0.3440.137safari/537.36'}referer=scrapy.get(headers=headers)scrapy.request(url=url,post=globaljsonitem,headers=headers)scrapy.items().urlparameter('url',list(request.text))fig=plt.figure()a=fig.add_subplot(2,2,1)name=globaljsonitem(a)aspnum=globaljsonitem(a)url=''url=''partial=globaljsonitem(aspnum)url='"\s+"\s+"\s+"\s+"+"\s+"\s+"\s+"+"\s+"\s+"+"\s+"'content=scrapy.extract_text(url,encoding='utf-8')withopen('test.txt','w+')asfp:fp.write(content)请求进入到后台，content.follow('/')，可以看到，此时请求是从创建爬虫的giteawall.py文件开始抓取下来的，爬虫之后，就可以去掉设置参数/urlname/aspnum这两项，返回第二个session对象。
爬虫对象是一个返回列表并列举着所有已爬取url的web服务器。可以看到url这个数组不包含参数，而web服务器这个函数不是很难的，可以读取文件，referer当然也是用来设置必要参数的。既然是request方法，可以看下响应的处理，item是http请求内容，headers当然是必要参数了，和request是一样的。
//name是giteawall.py的name方法classgiteawall:def__init__(self,name):self.name=nameself.spider。 查看全部
scrapy分页抓取网页(scrapy分页抓取网页信息实现网络爬虫和抓包分析器-scrapy)
scrapy分页抓取网页信息实现网络爬虫和抓包分析器-scrapy中文文档-csdn博客-中国最大的it技术社区scrapy是一个开源的pythonweb框架，它提供了一个功能强大的networkapi，可以让爬虫获取网络网页信息和重定向网页从而爬取动态网页。scrapy的核心是用于在scrapyweb框架中创建和利用多线程抓取和分析网页的核心功能。
scrapy通过分层的scrapyweb框架将请求或响应流传递给下游爬虫/job可以进行不同的数据抓取。scrapy支持windows、linux和mac系统。我们分别在mac和windows系统环境下做演示。scrapy分页抓取网页信息实现代码：importscrapyclassglobaljsonitem:name=scrapy.field(scrapy.field())aspnum=scrapy.field(scrapy.field())url=''headers={'user-agent':'mozilla/5.0(windowsnt10.0;win64;x64)applewebkit/537.36(khtml,likegecko)chrome/72.0.3440.137safari/537.36'}referer=scrapy.get(headers=headers)scrapy.request(url=url,post=globaljsonitem,headers=headers)scrapy.items().urlparameter('url',list(request.text))fig=plt.figure()a=fig.add_subplot(2,2,1)name=globaljsonitem(a)aspnum=globaljsonitem(a)url=''url=''partial=globaljsonitem(aspnum)url='"\s+"\s+"\s+"\s+"+"\s+"\s+"\s+"+"\s+"\s+"+"\s+"'content=scrapy.extract_text(url,encoding='utf-8')withopen('test.txt','w+')asfp:fp.write(content)请求进入到后台，content.follow('/')，可以看到，此时请求是从创建爬虫的giteawall.py文件开始抓取下来的，爬虫之后，就可以去掉设置参数/urlname/aspnum这两项，返回第二个session对象。
爬虫对象是一个返回列表并列举着所有已爬取url的web服务器。可以看到url这个数组不包含参数，而web服务器这个函数不是很难的，可以读取文件，referer当然也是用来设置必要参数的。既然是request方法，可以看下响应的处理，item是http请求内容，headers当然是必要参数了，和request是一样的。
//name是giteawall.py的name方法classgiteawall:def__init__(self,name):self.name=nameself.spider。
scrapy分页抓取网页(一下爬虫爬虫项目的基本步骤和基本操作步骤（一）)
网站优化 • 优采云 发表了文章 • 0 个评论 • 50 次浏览 • 2022-02-11 10:16
scrapy分页抓取网页(一下爬虫爬虫项目的基本步骤和基本操作步骤（一）)
Python爬虫--scrapy爬虫框架介绍写在前面
在编写爬虫之前，我从未使用过爬虫框架。其实我之前写的就是一个爬虫写的小练习的demo。只能说是从网上抓取一点数据，直接用python脚本解决爬虫的所有功能。循环获取更多数据页。后来了解了代理池系统，稍微了解了一下爬虫其实也可以算是一个项目。该项目分为模块。不同的模块负责不同的功能。有些模块负责封装http请求，有些模块负责处理请求。（数据采集），有些模块负责数据分析，有些模块负责数据存储。这样一个框架的原型已经出现，这可以帮助我们更加专注和高效地抓取数据。对于scrapy，一开始并不想解释scrapy框架的太多部分和功能，而是直接在实际操作中去感受一下框架是如何分工协作的，各个模块负责什么功能，最后关注一下这个框架。一些原则应该是学习scrapy框架的最好方法。
scrapy爬虫的基本步骤创建一个scrapy爬虫项目。创建一个 Spider 爬虫类来爬取网页内容并解析它。定义数据模型（Item）并将捕获的数据封装到Item中。使用Item Pipeline来存储和抓取Items，即数据实体对象。一、创建一个scrapy爬虫项目
安装scrapy后，运行命令scrapy startproject project name，创建scrapy爬虫项目。例如运行scrapy startproject test1会生成一个test1文件夹，目录结构如下：
二、创建一个Spider爬虫类来爬取网页内容并解析它。
爬虫的代码写在spider文件夹下，所以在spider目录下创建一个python文件，爬取方天下的数据，所以创建一个python文件，命名为ftx_spider.py。
接下来，开始在 ftx_spider.py 中编写爬虫代码：
import scrapy
class FtxSpider(scrapy.Spider):
"""
一、创建一个爬虫类，继承scrapy.Spider
二、通过name属性，给爬虫类定义一个名称
三、指定要抓取的网页链接urls，发送http请求
方式一：
1.继承scrapy.Spider的start_requests()方法。
2.指定要爬取的url，通过scrapy.Request(url=url, callback=self.parse)发送请求，callback指定解析函数。
方式二(简化)：
1.直接通过start_urls常量指定要爬取的urls。
2.框架会自动发送http请求，这里框架默认html解析函数parse().
四、针对http请求的response结果，编写解析方法，parse()
"""
name = 'ftx'
# 方式一：通过scrapy.Request(url=url, callback=self.parse)发送请求，指定解析函数
# def start_requests(self):
# urls = ['http://wuhan.esf.fang.com/hous ... 39%3B]
# for url in urls:
# yield scrapy.Request(url=url, callback=self.parse)
#
# def parse(self, response):
# # 这里对抓取到的html页面进行解析
# print(response.url)
# 方式二(简化版)：通过start_urls，框架自动发送请求，默认解析函数为parse()
start_urls = ['http://wuhan.esf.fang.com/hous ... 39%3B]
def parse(self, response):
print(response.url)
三、数据模型Item，定义爬取数据的数据结构
这个Item相当于java中的域实体，或者javabean。在 items.py 中定义了一个类，它继承了 scrapy.Item。这样我们就可以将我们抓取的数据封装到一个对象中。
import scrapy
class FtxSpiderItem(scrapy.Item):
# define the fields for your item here like:
title = scrapy.Field() # 标题
huxing = scrapy.Field() # 户型
size = scrapy.Field() # 面积
floor = scrapy.Field() # 楼层
fangxiang = scrapy.Field() # 方向
year = scrapy.Field() # 建房时间
shop_community = scrapy.Field() # 小区
address = scrapy.Field() # 地址
total_price = scrapy.Field() # 总价（万）
price = scrapy.Field() # 单价（万/m2）
四、使用Item Pipeline存储和抓取item并将数据存储在MongoDB中
项目管道是项目管道。当 Item 生成后，会自动发送到 Item Pipeline 进行处理。
首先在setting.py中添加MongoDB数据库连接信息
# MongoDB
HOST = 'localhost'
PORT = 27017
DB_NAME = 'ftx'
COLL_NAME = 'roomprice'
然后在pipelines.py中创建一个类，连接数据库，插入数据
import pymongo
from scrapy.conf import settings
class FtxSpiderPipeline(object):
def __init__(self):
# 连接MongoDB
self.client = pymongo.MongoClient(host=settings['HOST'], port=settings['PORT'])
# 获取数据库
self.db = self.client[settings['DB_NAME']]
# 获取集合
self.collection = self.db[settings['COLL_NAME']]
def process_item(self, item, spider):
self.collection.insert(dict(item))
最后在setting.py中指定Item Pipeline使用的类和优先级
ITEM_PIPELINES = {
'ftx_spider.pipelines.FtxSpiderPipeline': 300
}
运行命令行scrapy crawl 'crawler name name'，可以发现数据已经成功存入数据库，代码地址完整 查看全部
Python爬虫--scrapy爬虫框架介绍写在前面
在编写爬虫之前，我从未使用过爬虫框架。其实我之前写的就是一个爬虫写的小练习的demo。只能说是从网上抓取一点数据，直接用python脚本解决爬虫的所有功能。循环获取更多数据页。后来了解了代理池系统，稍微了解了一下爬虫其实也可以算是一个项目。该项目分为模块。不同的模块负责不同的功能。有些模块负责封装http请求，有些模块负责处理请求。（数据采集），有些模块负责数据分析，有些模块负责数据存储。这样一个框架的原型已经出现，这可以帮助我们更加专注和高效地抓取数据。对于scrapy，一开始并不想解释scrapy框架的太多部分和功能，而是直接在实际操作中去感受一下框架是如何分工协作的，各个模块负责什么功能，最后关注一下这个框架。一些原则应该是学习scrapy框架的最好方法。
scrapy爬虫的基本步骤创建一个scrapy爬虫项目。创建一个 Spider 爬虫类来爬取网页内容并解析它。定义数据模型（Item）并将捕获的数据封装到Item中。使用Item Pipeline来存储和抓取Items，即数据实体对象。一、创建一个scrapy爬虫项目
安装scrapy后，运行命令scrapy startproject project name，创建scrapy爬虫项目。例如运行scrapy startproject test1会生成一个test1文件夹，目录结构如下：
二、创建一个Spider爬虫类来爬取网页内容并解析它。
爬虫的代码写在spider文件夹下，所以在spider目录下创建一个python文件，爬取方天下的数据，所以创建一个python文件，命名为ftx_spider.py。
接下来，开始在 ftx_spider.py 中编写爬虫代码：
import scrapy
class FtxSpider(scrapy.Spider):
"""
一、创建一个爬虫类，继承scrapy.Spider
二、通过name属性，给爬虫类定义一个名称
三、指定要抓取的网页链接urls，发送http请求
方式一：
1.继承scrapy.Spider的start_requests()方法。
2.指定要爬取的url，通过scrapy.Request(url=url, callback=self.parse)发送请求，callback指定解析函数。
方式二(简化)：
1.直接通过start_urls常量指定要爬取的urls。
2.框架会自动发送http请求，这里框架默认html解析函数parse().
四、针对http请求的response结果，编写解析方法，parse()
"""
name = 'ftx'
# 方式一：通过scrapy.Request(url=url, callback=self.parse)发送请求，指定解析函数
# def start_requests(self):
# urls = ['http://wuhan.esf.fang.com/hous ... 39%3B]
# for url in urls:
# yield scrapy.Request(url=url, callback=self.parse)
#
# def parse(self, response):
# # 这里对抓取到的html页面进行解析
# print(response.url)
# 方式二(简化版)：通过start_urls，框架自动发送请求，默认解析函数为parse()
start_urls = ['http://wuhan.esf.fang.com/hous ... 39%3B]
def parse(self, response):
print(response.url)
三、数据模型Item，定义爬取数据的数据结构
这个Item相当于java中的域实体，或者javabean。在 items.py 中定义了一个类，它继承了 scrapy.Item。这样我们就可以将我们抓取的数据封装到一个对象中。
import scrapy
class FtxSpiderItem(scrapy.Item):
# define the fields for your item here like:
title = scrapy.Field() # 标题
huxing = scrapy.Field() # 户型
size = scrapy.Field() # 面积
floor = scrapy.Field() # 楼层
fangxiang = scrapy.Field() # 方向
year = scrapy.Field() # 建房时间
shop_community = scrapy.Field() # 小区
address = scrapy.Field() # 地址
total_price = scrapy.Field() # 总价（万）
price = scrapy.Field() # 单价（万/m2）
四、使用Item Pipeline存储和抓取item并将数据存储在MongoDB中
项目管道是项目管道。当 Item 生成后，会自动发送到 Item Pipeline 进行处理。
首先在setting.py中添加MongoDB数据库连接信息
# MongoDB
HOST = 'localhost'
PORT = 27017
DB_NAME = 'ftx'
COLL_NAME = 'roomprice'
然后在pipelines.py中创建一个类，连接数据库，插入数据
import pymongo
from scrapy.conf import settings
class FtxSpiderPipeline(object):
def __init__(self):
# 连接MongoDB
self.client = pymongo.MongoClient(host=settings['HOST'], port=settings['PORT'])
# 获取数据库
self.db = self.client[settings['DB_NAME']]
# 获取集合
self.collection = self.db[settings['COLL_NAME']]
def process_item(self, item, spider):
self.collection.insert(dict(item))
最后在setting.py中指定Item Pipeline使用的类和优先级
ITEM_PIPELINES = {
'ftx_spider.pipelines.FtxSpiderPipeline': 300
}
运行命令行scrapy crawl 'crawler name name'，可以发现数据已经成功存入数据库，代码地址完整 查看全部
scrapy分页抓取网页(一下爬虫爬虫项目的基本步骤和基本操作步骤（一）)
Python爬虫--scrapy爬虫框架介绍写在前面
在编写爬虫之前，我从未使用过爬虫框架。其实我之前写的就是一个爬虫写的小练习的demo。只能说是从网上抓取一点数据，直接用python脚本解决爬虫的所有功能。循环获取更多数据页。后来了解了代理池系统，稍微了解了一下爬虫其实也可以算是一个项目。该项目分为模块。不同的模块负责不同的功能。有些模块负责封装http请求，有些模块负责处理请求。（数据采集），有些模块负责数据分析，有些模块负责数据存储。这样一个框架的原型已经出现，这可以帮助我们更加专注和高效地抓取数据。对于scrapy，一开始并不想解释scrapy框架的太多部分和功能，而是直接在实际操作中去感受一下框架是如何分工协作的，各个模块负责什么功能，最后关注一下这个框架。一些原则应该是学习scrapy框架的最好方法。
scrapy爬虫的基本步骤创建一个scrapy爬虫项目。创建一个 Spider 爬虫类来爬取网页内容并解析它。定义数据模型（Item）并将捕获的数据封装到Item中。使用Item Pipeline来存储和抓取Items，即数据实体对象。一、创建一个scrapy爬虫项目
安装scrapy后，运行命令scrapy startproject project name，创建scrapy爬虫项目。例如运行scrapy startproject test1会生成一个test1文件夹，目录结构如下：
二、创建一个Spider爬虫类来爬取网页内容并解析它。
爬虫的代码写在spider文件夹下，所以在spider目录下创建一个python文件，爬取方天下的数据，所以创建一个python文件，命名为ftx_spider.py。
接下来，开始在 ftx_spider.py 中编写爬虫代码：
import scrapy
class FtxSpider(scrapy.Spider):
"""
一、创建一个爬虫类，继承scrapy.Spider
二、通过name属性，给爬虫类定义一个名称
三、指定要抓取的网页链接urls，发送http请求
方式一：
1.继承scrapy.Spider的start_requests()方法。
2.指定要爬取的url，通过scrapy.Request(url=url, callback=self.parse)发送请求，callback指定解析函数。
方式二(简化)：
1.直接通过start_urls常量指定要爬取的urls。
2.框架会自动发送http请求，这里框架默认html解析函数parse().
四、针对http请求的response结果，编写解析方法，parse()
"""
name = 'ftx'
# 方式一：通过scrapy.Request(url=url, callback=self.parse)发送请求，指定解析函数
# def start_requests(self):
# urls = ['http://wuhan.esf.fang.com/hous ... 39%3B]
# for url in urls:
# yield scrapy.Request(url=url, callback=self.parse)
#
# def parse(self, response):
# # 这里对抓取到的html页面进行解析
# print(response.url)
# 方式二(简化版)：通过start_urls，框架自动发送请求，默认解析函数为parse()
start_urls = ['http://wuhan.esf.fang.com/hous ... 39%3B]
def parse(self, response):
print(response.url)
三、数据模型Item，定义爬取数据的数据结构
这个Item相当于java中的域实体，或者javabean。在 items.py 中定义了一个类，它继承了 scrapy.Item。这样我们就可以将我们抓取的数据封装到一个对象中。
import scrapy
class FtxSpiderItem(scrapy.Item):
# define the fields for your item here like:
title = scrapy.Field() # 标题
huxing = scrapy.Field() # 户型
size = scrapy.Field() # 面积
floor = scrapy.Field() # 楼层
fangxiang = scrapy.Field() # 方向
year = scrapy.Field() # 建房时间
shop_community = scrapy.Field() # 小区
address = scrapy.Field() # 地址
total_price = scrapy.Field() # 总价（万）
price = scrapy.Field() # 单价（万/m2）
四、使用Item Pipeline存储和抓取item并将数据存储在MongoDB中
项目管道是项目管道。当 Item 生成后，会自动发送到 Item Pipeline 进行处理。
首先在setting.py中添加MongoDB数据库连接信息
# MongoDB
HOST = 'localhost'
PORT = 27017
DB_NAME = 'ftx'
COLL_NAME = 'roomprice'
然后在pipelines.py中创建一个类，连接数据库，插入数据
import pymongo
from scrapy.conf import settings
class FtxSpiderPipeline(object):
def __init__(self):
# 连接MongoDB
self.client = pymongo.MongoClient(host=settings['HOST'], port=settings['PORT'])
# 获取数据库
self.db = self.client[settings['DB_NAME']]
# 获取集合
self.collection = self.db[settings['COLL_NAME']]
def process_item(self, item, spider):
self.collection.insert(dict(item))
最后在setting.py中指定Item Pipeline使用的类和优先级
ITEM_PIPELINES = {
'ftx_spider.pipelines.FtxSpiderPipeline': 300
}
运行命令行scrapy crawl 'crawler name name'，可以发现数据已经成功存入数据库，代码地址完整
scrapy分页抓取网页(蜘蛛池博客原文链接：如何让网站更符合搜索引擎的抓取规则？)
网站优化 • 优采云 发表了文章 • 0 个评论 • 94 次浏览 • 2022-02-11 08:23
scrapy分页抓取网页(蜘蛛池博客原文链接：如何让网站更符合搜索引擎的抓取规则？)
原文来源：蜘蛛池博客
原文链接：如何让网站更符合搜索引擎的爬取规则？- 蜘蛛池博客
如果一个网站可以被搜索引擎频繁爬取，说明搜索引擎非常信任这个网站，所以赋予网站的权重也很高，关键词排名，网站流量会上升。那么，如何让网站更符合搜索引擎的爬取规则呢？接下来，蜘蛛池博客的小编给大家分享一下更符合搜索引擎爬取的规则网站，一起来看看吧！
1.设置清晰网站地图
说到网站图，很不起眼，相信很容易被大家忽略。当搜索引擎来到网站时，一开始并不清楚这个网站有哪些页面，哪些是新添加的，哪些是原来的。网站的所有页面一目了然，让搜索引擎对网站的所有页面一目了然，而不是一一查找。通过网站图，搜索引擎可以快速浏览整个网站的内容，快速爬取收录页面，这样网站收录就是很快，搜索引擎也愿意经常来网站。
2.网站结构和层次
网站 的结构非常重要。现在网站的结构主要有两种，一种是扁平结构，一种是树状结构。现在市场主要以树结构为主。它很容易管理。对于 网站 级别，它不应该太深。一般建议在三个级别以内。首页是一级，栏目页和分类页是一级，信息详情页和产品详情页是一级。这个三级页面方便蜘蛛快速爬取页面和内容。网站必须简化代码，以便蜘蛛能够快速爬行。
3.优质外链吸引蜘蛛
每天发布优质内容是一件很悲哀的事情，但百度蜘蛛并不在意。因此，对于很多外链强的老网站来说，建立优质的外链和访问渠道是没有问题的。如果你的 网站 是一个新站点，并且外部链接很少，你可以采取这种方法。新的内容页面发布后，会去一些优质的平台或新闻源外链，很快蜘蛛就会从这些网站爬到你那里。对新的内容页面进行爬网和索引。
4.内容页面质量
内容页面的质量是网站优化的重中之重。只有质量更好的内容才能吸引蜘蛛爬取，同时才能留住用户对你网站的关注；搜索引擎蜘蛛完成爬取后，下一步就是索引。如果这一步成功，我们的内容就可以进入百度的数据库，下一步就可以展示在用户面前了。
5.网站的更新频率
蜘蛛会存储每次爬取的网站，方便第二次爬取。如果第二次爬到你优化的网站，发现页面已经更新，蜘蛛就会爬到你的新内容每天更新，蜘蛛也会养成爬你的网站的习惯每天定期。
<p>总结：以上就是蜘蛛池博客小编想跟大家分享的，比较符合搜索引擎爬取网站的规则，希望对大家 查看全部
原文来源：蜘蛛池博客
原文链接：如何让网站更符合搜索引擎的爬取规则？- 蜘蛛池博客
如果一个网站可以被搜索引擎频繁爬取，说明搜索引擎非常信任这个网站，所以赋予网站的权重也很高，关键词排名，网站流量会上升。那么，如何让网站更符合搜索引擎的爬取规则呢？接下来，蜘蛛池博客的小编给大家分享一下更符合搜索引擎爬取的规则网站，一起来看看吧！
1.设置清晰网站地图
说到网站图，很不起眼，相信很容易被大家忽略。当搜索引擎来到网站时，一开始并不清楚这个网站有哪些页面，哪些是新添加的，哪些是原来的。网站的所有页面一目了然，让搜索引擎对网站的所有页面一目了然，而不是一一查找。通过网站图，搜索引擎可以快速浏览整个网站的内容，快速爬取收录页面，这样网站收录就是很快，搜索引擎也愿意经常来网站。
2.网站结构和层次
网站 的结构非常重要。现在网站的结构主要有两种，一种是扁平结构，一种是树状结构。现在市场主要以树结构为主。它很容易管理。对于 网站 级别，它不应该太深。一般建议在三个级别以内。首页是一级，栏目页和分类页是一级，信息详情页和产品详情页是一级。这个三级页面方便蜘蛛快速爬取页面和内容。网站必须简化代码，以便蜘蛛能够快速爬行。
3.优质外链吸引蜘蛛
每天发布优质内容是一件很悲哀的事情，但百度蜘蛛并不在意。因此，对于很多外链强的老网站来说，建立优质的外链和访问渠道是没有问题的。如果你的 网站 是一个新站点，并且外部链接很少，你可以采取这种方法。新的内容页面发布后，会去一些优质的平台或新闻源外链，很快蜘蛛就会从这些网站爬到你那里。对新的内容页面进行爬网和索引。
4.内容页面质量
内容页面的质量是网站优化的重中之重。只有质量更好的内容才能吸引蜘蛛爬取，同时才能留住用户对你网站的关注；搜索引擎蜘蛛完成爬取后，下一步就是索引。如果这一步成功，我们的内容就可以进入百度的数据库，下一步就可以展示在用户面前了。
5.网站的更新频率
蜘蛛会存储每次爬取的网站，方便第二次爬取。如果第二次爬到你优化的网站，发现页面已经更新，蜘蛛就会爬到你的新内容每天更新，蜘蛛也会养成爬你的网站的习惯每天定期。
<p>总结：以上就是蜘蛛池博客小编想跟大家分享的，比较符合搜索引擎爬取网站的规则，希望对大家 查看全部
scrapy分页抓取网页(蜘蛛池博客原文链接：如何让网站更符合搜索引擎的抓取规则？)
原文来源：蜘蛛池博客
原文链接：如何让网站更符合搜索引擎的爬取规则？- 蜘蛛池博客
如果一个网站可以被搜索引擎频繁爬取，说明搜索引擎非常信任这个网站，所以赋予网站的权重也很高，关键词排名，网站流量会上升。那么，如何让网站更符合搜索引擎的爬取规则呢？接下来，蜘蛛池博客的小编给大家分享一下更符合搜索引擎爬取的规则网站，一起来看看吧！
1.设置清晰网站地图
说到网站图，很不起眼，相信很容易被大家忽略。当搜索引擎来到网站时，一开始并不清楚这个网站有哪些页面，哪些是新添加的，哪些是原来的。网站的所有页面一目了然，让搜索引擎对网站的所有页面一目了然，而不是一一查找。通过网站图，搜索引擎可以快速浏览整个网站的内容，快速爬取收录页面，这样网站收录就是很快，搜索引擎也愿意经常来网站。
2.网站结构和层次
网站 的结构非常重要。现在网站的结构主要有两种，一种是扁平结构，一种是树状结构。现在市场主要以树结构为主。它很容易管理。对于 网站 级别，它不应该太深。一般建议在三个级别以内。首页是一级，栏目页和分类页是一级，信息详情页和产品详情页是一级。这个三级页面方便蜘蛛快速爬取页面和内容。网站必须简化代码，以便蜘蛛能够快速爬行。
3.优质外链吸引蜘蛛
每天发布优质内容是一件很悲哀的事情，但百度蜘蛛并不在意。因此，对于很多外链强的老网站来说，建立优质的外链和访问渠道是没有问题的。如果你的 网站 是一个新站点，并且外部链接很少，你可以采取这种方法。新的内容页面发布后，会去一些优质的平台或新闻源外链，很快蜘蛛就会从这些网站爬到你那里。对新的内容页面进行爬网和索引。
4.内容页面质量
内容页面的质量是网站优化的重中之重。只有质量更好的内容才能吸引蜘蛛爬取，同时才能留住用户对你网站的关注；搜索引擎蜘蛛完成爬取后，下一步就是索引。如果这一步成功，我们的内容就可以进入百度的数据库，下一步就可以展示在用户面前了。
5.网站的更新频率
蜘蛛会存储每次爬取的网站，方便第二次爬取。如果第二次爬到你优化的网站，发现页面已经更新，蜘蛛就会爬到你的新内容每天更新，蜘蛛也会养成爬你的网站的习惯每天定期。
<p>总结：以上就是蜘蛛池博客小编想跟大家分享的，比较符合搜索引擎爬取网站的规则，希望对大家
scrapy分页抓取网页(WebScraper的一个扩展插件，安装后你可以直接在F12调试工具里使用)
网站优化 • 优采云 发表了文章 • 0 个评论 • 49 次浏览 • 2022-02-08 06:23
scrapy分页抓取网页(WebScraper的一个扩展插件，安装后你可以直接在F12调试工具里使用)
经常遇到一些简单的需求，需要在某个网站上爬取一些数据，但是这些页面的结构很简单，数据量也比较少。自己写代码是可以的，但是没用。牛刀？
目前市面上有一些成熟的零码爬虫工具，比如优采云，有现成的模板可以使用，一些爬取规则也可以自己定义。但是我今天要介绍的是另一个神器——Web Scraper，它是Chrome浏览器的扩展。安装后，可以直接在F12调试工具中使用。
# 1. 安装网络爬虫
有条件的同学，可以直接在商店搜索Web Scraper进行安装
没有条件的同学可以到这个网站(/)下载crx文件，然后离线安装。具体方法可以借助搜索引擎解决。
安装后需要重启一次Chrome，然后F12才能看到工具
# 2. 基本概念和操作
在使用 Web Scraper 之前，需要先解释一下它的一些基本概念：
网站地图
直译为网站map，有了这个地图爬虫就可以跟着它获取我们需要的数据。
所以sitemap其实可以理解为网站的爬虫程序。要爬取多个 网站 数据，需要定义多个站点地图。
站点地图支持导出和导入，这意味着您编写的站点地图可以与他人共享。
从下图可以看出，sitemap代码是一串JSON配置
只要拿到这个配置，就可以导入别人的站点地图
选择器
直译过来就是一个选择器。要从一个充满数据的 HTML 页面中提取数据，需要一个选择器来定位我们数据的具体位置。
每个 Selector 可以获取一条数据。要获取多条数据，需要定位多个 Selector。
Web Scraper 提供的 Selector 有很多，但本文文章 只介绍几个使用最频繁、覆盖面最广的 Selector。了解一二之后，其他的原理都差不多。可以上手了。
Web Scraper 使用 CSS 选择器来定位元素。如果你不知道，没关系。在大多数场景下，您可以直接通过鼠标点击选择元素，Web Scraper 会自动解析相应的 CSS。小路。
Selector 可以嵌套，子 Selector 的 CSS 选择器作用域就是父 Selector。
正是这种无穷无尽的嵌套关系让我们能够递归地爬取整个 网站 数据。
下面是我们后面经常放的选择器拓扑，可以用来直观的展示Web Scraper的爬取逻辑
数据抓取和导出
定义站点地图规则后，单击“抓取”开始抓取数据。
爬取数据后，不会立即显示在页面上，需要再次手动点击刷新按钮才能看到数据。
最终数据也可以导出为 csv 或 xlsx 文件。
# 3. 寻呼机爬取
爬取数据最经典的模型是列表、分页和明细。接下来我也会围绕这个方向爬取CSDN博客文章来介绍几个Selector的用法。
寻呼机可以分为两种类型：
在早期版本的 web-scraper 中，两种爬取方式是不同的。
对于一些 网站 来说确实足够了，但有很大的局限性。
经过我的实验，使用Link选择器的第一个原理是在下一页取出a标签的超链接，然后访问它，但并不是所有网站的下一页都是通过a标签实现的.
如果用js监听事件然后像下面这样跳转，就不能使用Link选择器了。
在新版本的网络爬虫中，它提供了对导航分页器的特殊支持，并增加了一个分页选择器，可以完全适用于两种场景，我将在下面进行演示。
寻呼机爬行而不重新加载页面
点击具体的CSDN博文，拉到底部，就可以看到评论区了。
如果你的文章比较热门，有很多同学评论，CSDN会分页显示，但是不管在哪个页面评论都属于同一篇文章文章，你浏览的时候当你在任何页面的评论区时，博文不需要刷新，因为这个分页不会重新加载页面。
对于这种不需要重新加载页面的点击，可以使用Element Click来解决。
最后一点必须注意，要选择root和next_page，只有这样才能递归爬取
最终爬取效果如下
使用Element Click的站点地图配置如下，可以直接导入我的配置进行研究，下载配置文件：/iidSSugkch
当然，对于分页之类的东西，网页爬虫提供了更专业的分页选择器，配置更精简，效果最好。
对应sitemap的配置如下，可以直接导入使用。下载配置文件：/iidSSugkch
寻呼机爬行以重新加载页面
CSDN的博客文章列表，拉到底部，点击具体页面按钮，否则最右边的下一页会重新加载当前页面。
对于这种分页器，Element Click 什么都做不了，读者可以自行验证，最多爬一页就会关闭。
而且作为一个为分页而生的Pagination选择器，自然适用
爬取的拓扑同上，这里不再赘述。
对应sitemap的配置如下，可以直接导入学习，下载配置文件：/iidSSugkch
# 4. 次要页面的爬取
CSDN的博客列表列表页，显示的信息比较粗略，只有标题，发表时间，阅读量，评论数，是否是原创。
如果你想获得更多的信息，比如博文的文字、点赞数、采集数、评论区的内容，你必须点击具体的博文链接才能查看。
网络爬虫的操作逻辑与人类相同。如果你想抓取更详细的博文信息，你必须打开一个新的页面来获取它，而网络爬虫的链接选择器恰好做到了这一点。
爬取路径拓扑如下
爬取的效果如下
sitemap的配置如下，可以直接导入使用。下载配置文件：/iidSSugkch
# 5. 最后
以上整理了分页和二级页面的爬取方案，主要有：分页器爬取和二级页面爬取。
只要学会了这两个，就已经可以处理绝大多数结构化的网络数据了。 查看全部
经常遇到一些简单的需求，需要在某个网站上爬取一些数据，但是这些页面的结构很简单，数据量也比较少。自己写代码是可以的，但是没用。牛刀？
目前市面上有一些成熟的零码爬虫工具，比如优采云，有现成的模板可以使用，一些爬取规则也可以自己定义。但是我今天要介绍的是另一个神器——Web Scraper，它是Chrome浏览器的扩展。安装后，可以直接在F12调试工具中使用。
# 1. 安装网络爬虫
有条件的同学，可以直接在商店搜索Web Scraper进行安装
没有条件的同学可以到这个网站(/)下载crx文件，然后离线安装。具体方法可以借助搜索引擎解决。
安装后需要重启一次Chrome，然后F12才能看到工具
# 2. 基本概念和操作
在使用 Web Scraper 之前，需要先解释一下它的一些基本概念：
网站地图
直译为网站map，有了这个地图爬虫就可以跟着它获取我们需要的数据。
所以sitemap其实可以理解为网站的爬虫程序。要爬取多个 网站 数据，需要定义多个站点地图。
站点地图支持导出和导入，这意味着您编写的站点地图可以与他人共享。
从下图可以看出，sitemap代码是一串JSON配置
只要拿到这个配置，就可以导入别人的站点地图
选择器
直译过来就是一个选择器。要从一个充满数据的 HTML 页面中提取数据，需要一个选择器来定位我们数据的具体位置。
每个 Selector 可以获取一条数据。要获取多条数据，需要定位多个 Selector。
Web Scraper 提供的 Selector 有很多，但本文文章 只介绍几个使用最频繁、覆盖面最广的 Selector。了解一二之后，其他的原理都差不多。可以上手了。
Web Scraper 使用 CSS 选择器来定位元素。如果你不知道，没关系。在大多数场景下，您可以直接通过鼠标点击选择元素，Web Scraper 会自动解析相应的 CSS。小路。
Selector 可以嵌套，子 Selector 的 CSS 选择器作用域就是父 Selector。
正是这种无穷无尽的嵌套关系让我们能够递归地爬取整个 网站 数据。
下面是我们后面经常放的选择器拓扑，可以用来直观的展示Web Scraper的爬取逻辑
数据抓取和导出
定义站点地图规则后，单击“抓取”开始抓取数据。
爬取数据后，不会立即显示在页面上，需要再次手动点击刷新按钮才能看到数据。
最终数据也可以导出为 csv 或 xlsx 文件。
# 3. 寻呼机爬取
爬取数据最经典的模型是列表、分页和明细。接下来我也会围绕这个方向爬取CSDN博客文章来介绍几个Selector的用法。
寻呼机可以分为两种类型：
在早期版本的 web-scraper 中，两种爬取方式是不同的。
对于一些 网站 来说确实足够了，但有很大的局限性。
经过我的实验，使用Link选择器的第一个原理是在下一页取出a标签的超链接，然后访问它，但并不是所有网站的下一页都是通过a标签实现的.
如果用js监听事件然后像下面这样跳转，就不能使用Link选择器了。
在新版本的网络爬虫中，它提供了对导航分页器的特殊支持，并增加了一个分页选择器，可以完全适用于两种场景，我将在下面进行演示。
寻呼机爬行而不重新加载页面
点击具体的CSDN博文，拉到底部，就可以看到评论区了。
如果你的文章比较热门，有很多同学评论，CSDN会分页显示，但是不管在哪个页面评论都属于同一篇文章文章，你浏览的时候当你在任何页面的评论区时，博文不需要刷新，因为这个分页不会重新加载页面。
对于这种不需要重新加载页面的点击，可以使用Element Click来解决。
最后一点必须注意，要选择root和next_page，只有这样才能递归爬取
最终爬取效果如下
使用Element Click的站点地图配置如下，可以直接导入我的配置进行研究，下载配置文件：/iidSSugkch
当然，对于分页之类的东西，网页爬虫提供了更专业的分页选择器，配置更精简，效果最好。
对应sitemap的配置如下，可以直接导入使用。下载配置文件：/iidSSugkch
寻呼机爬行以重新加载页面
CSDN的博客文章列表，拉到底部，点击具体页面按钮，否则最右边的下一页会重新加载当前页面。
对于这种分页器，Element Click 什么都做不了，读者可以自行验证，最多爬一页就会关闭。
而且作为一个为分页而生的Pagination选择器，自然适用
爬取的拓扑同上，这里不再赘述。
对应sitemap的配置如下，可以直接导入学习，下载配置文件：/iidSSugkch
# 4. 次要页面的爬取
CSDN的博客列表列表页，显示的信息比较粗略，只有标题，发表时间，阅读量，评论数，是否是原创。
如果你想获得更多的信息，比如博文的文字、点赞数、采集数、评论区的内容，你必须点击具体的博文链接才能查看。
网络爬虫的操作逻辑与人类相同。如果你想抓取更详细的博文信息，你必须打开一个新的页面来获取它，而网络爬虫的链接选择器恰好做到了这一点。
爬取路径拓扑如下
爬取的效果如下
sitemap的配置如下，可以直接导入使用。下载配置文件：/iidSSugkch
# 5. 最后
以上整理了分页和二级页面的爬取方案，主要有：分页器爬取和二级页面爬取。
只要学会了这两个，就已经可以处理绝大多数结构化的网络数据了。 查看全部
scrapy分页抓取网页(WebScraper的一个扩展插件，安装后你可以直接在F12调试工具里使用)
经常遇到一些简单的需求，需要在某个网站上爬取一些数据，但是这些页面的结构很简单，数据量也比较少。自己写代码是可以的，但是没用。牛刀？
目前市面上有一些成熟的零码爬虫工具，比如优采云，有现成的模板可以使用，一些爬取规则也可以自己定义。但是我今天要介绍的是另一个神器——Web Scraper，它是Chrome浏览器的扩展。安装后，可以直接在F12调试工具中使用。
# 1. 安装网络爬虫
有条件的同学，可以直接在商店搜索Web Scraper进行安装
没有条件的同学可以到这个网站(/)下载crx文件，然后离线安装。具体方法可以借助搜索引擎解决。
安装后需要重启一次Chrome，然后F12才能看到工具
# 2. 基本概念和操作
在使用 Web Scraper 之前，需要先解释一下它的一些基本概念：
网站地图
直译为网站map，有了这个地图爬虫就可以跟着它获取我们需要的数据。
所以sitemap其实可以理解为网站的爬虫程序。要爬取多个 网站 数据，需要定义多个站点地图。
站点地图支持导出和导入，这意味着您编写的站点地图可以与他人共享。
从下图可以看出，sitemap代码是一串JSON配置
只要拿到这个配置，就可以导入别人的站点地图
选择器
直译过来就是一个选择器。要从一个充满数据的 HTML 页面中提取数据，需要一个选择器来定位我们数据的具体位置。
每个 Selector 可以获取一条数据。要获取多条数据，需要定位多个 Selector。
Web Scraper 提供的 Selector 有很多，但本文文章 只介绍几个使用最频繁、覆盖面最广的 Selector。了解一二之后，其他的原理都差不多。可以上手了。
Web Scraper 使用 CSS 选择器来定位元素。如果你不知道，没关系。在大多数场景下，您可以直接通过鼠标点击选择元素，Web Scraper 会自动解析相应的 CSS。小路。
Selector 可以嵌套，子 Selector 的 CSS 选择器作用域就是父 Selector。
正是这种无穷无尽的嵌套关系让我们能够递归地爬取整个 网站 数据。
下面是我们后面经常放的选择器拓扑，可以用来直观的展示Web Scraper的爬取逻辑
数据抓取和导出
定义站点地图规则后，单击“抓取”开始抓取数据。
爬取数据后，不会立即显示在页面上，需要再次手动点击刷新按钮才能看到数据。
最终数据也可以导出为 csv 或 xlsx 文件。
# 3. 寻呼机爬取
爬取数据最经典的模型是列表、分页和明细。接下来我也会围绕这个方向爬取CSDN博客文章来介绍几个Selector的用法。
寻呼机可以分为两种类型：
在早期版本的 web-scraper 中，两种爬取方式是不同的。
对于一些 网站 来说确实足够了，但有很大的局限性。
经过我的实验，使用Link选择器的第一个原理是在下一页取出a标签的超链接，然后访问它，但并不是所有网站的下一页都是通过a标签实现的.
如果用js监听事件然后像下面这样跳转，就不能使用Link选择器了。
在新版本的网络爬虫中，它提供了对导航分页器的特殊支持，并增加了一个分页选择器，可以完全适用于两种场景，我将在下面进行演示。
寻呼机爬行而不重新加载页面
点击具体的CSDN博文，拉到底部，就可以看到评论区了。
如果你的文章比较热门，有很多同学评论，CSDN会分页显示，但是不管在哪个页面评论都属于同一篇文章文章，你浏览的时候当你在任何页面的评论区时，博文不需要刷新，因为这个分页不会重新加载页面。
对于这种不需要重新加载页面的点击，可以使用Element Click来解决。
最后一点必须注意，要选择root和next_page，只有这样才能递归爬取
最终爬取效果如下
使用Element Click的站点地图配置如下，可以直接导入我的配置进行研究，下载配置文件：/iidSSugkch
当然，对于分页之类的东西，网页爬虫提供了更专业的分页选择器，配置更精简，效果最好。
对应sitemap的配置如下，可以直接导入使用。下载配置文件：/iidSSugkch
寻呼机爬行以重新加载页面
CSDN的博客文章列表，拉到底部，点击具体页面按钮，否则最右边的下一页会重新加载当前页面。
对于这种分页器，Element Click 什么都做不了，读者可以自行验证，最多爬一页就会关闭。
而且作为一个为分页而生的Pagination选择器，自然适用
爬取的拓扑同上，这里不再赘述。
对应sitemap的配置如下，可以直接导入学习，下载配置文件：/iidSSugkch
# 4. 次要页面的爬取
CSDN的博客列表列表页，显示的信息比较粗略，只有标题，发表时间，阅读量，评论数，是否是原创。
如果你想获得更多的信息，比如博文的文字、点赞数、采集数、评论区的内容，你必须点击具体的博文链接才能查看。
网络爬虫的操作逻辑与人类相同。如果你想抓取更详细的博文信息，你必须打开一个新的页面来获取它，而网络爬虫的链接选择器恰好做到了这一点。
爬取路径拓扑如下
爬取的效果如下
sitemap的配置如下，可以直接导入使用。下载配置文件：/iidSSugkch
# 5. 最后
以上整理了分页和二级页面的爬取方案，主要有：分页器爬取和二级页面爬取。
只要学会了这两个，就已经可以处理绝大多数结构化的网络数据了。
scrapy分页抓取网页(Scrapy高级Python爬虫框架 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 40 次浏览 • 2022-02-07 15:11
scrapy分页抓取网页(Scrapy高级Python爬虫框架
)
介绍
Scrapy 是一个高级的 Python 爬虫框架。它不仅收录爬虫功能，还可以方便地将爬虫数据保存为csv、json等文件。
首先我们安装 Scrapy。
它可用于数据挖掘、信息处理或存储历史数据等一系列程序中。它最初是为网页抓取（更准确地说，网页抓取）而设计的，但也可用于检索 API（例如 Amazon Associates Web 服务）或通用网络爬虫返回的数据。Scrapy 用途广泛，可用于数据挖掘、监控和自动化测试。
Scrapy 使用 Twisted 异步网络库来处理网络通信。整体结构大致如下
安装 linux 或 mac
pip3 install scrapy
视窗
#下载twisted
http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
#安装wheel模块之后才能安装.whl文件
pip3 install wheel
#安装twisted
pip install Twisted‑18.4.0‑cp36‑cp36m‑win_amd64.whl
pip3 install pywin32
#安装scrapy
pip3 install scrapy
使用创建项目
格式：scrapy startproject 项目名称
scrapy startproject spider
项目创建后会生成一个目录，如下：
项目名称/
- spiders # 爬虫文件
- chouti.py
- cnblgos.py
....
- items.py # 持久化
- pipelines # 持久化
- middlewares.py # 中间件
- settings.py # 配置文件（爬虫）
scrapy.cfg # 配置文件（部署）
创建爬虫
格式：
cd 项目名称
scrapy genspider 爬虫名称将被爬取 网站
cd spider
scrapy genspider chouti chouti.com
爬虫创建后会在spiders文件夹下生成一个文件
打开chouti.py后如下：
运行爬虫
scrapy crawl chouti
scrapy crawl chouti --nolog # 不打印日志
例子
# -*- coding: utf-8 -*-
import scrapy
class ChoutiSpider(scrapy.Spider):
'''
爬去抽屉网的帖子信息
'''
name = 'chouti'
allowed_domains = ['chouti.com']
start_urls = ['http://chouti.com/']
def parse(self, response):
# 获取帖子列表的父级div
content_div = response.xpath('//div[@id="content-list"]')
# 获取帖子item的列表
items_list = content_div.xpath('.//div[@class="item"]')
# 打开一个文件句柄，目的是为了将获取的东西写入文件
with open('articles.log','a+',encoding='utf-8') as f:
# 循环item_list
for item in items_list:
# 获取每个item的第一个a标签的文本和url链接
text = item.xpath('.//a/text()').extract_first()
href = item.xpath('.//a/@href').extract_first()
# print(href, text.strip())
# print('-'*100)
f.write(href+'\n')
f.write(text.strip()+'\n')
f.write('-'*100+'\n')
# 获取分页的页码，然后让程序循环爬去每个链接
# 页码标签对象列表
page_list = response.xpath('//div[@id="dig_lcpage"]')
# 循环列表
for page in page_list:
# 获取每个标签下的a标签的url，即每页的链接
page_a_url = page.xpath('.//a/@href').extract()
# 将域名和url拼接起来
page_url = 'https://dig.chouti.com' + page_a_url
# 重要的一步！！！！
# 导入Request模块，然后实例化一个Request对象，然后yield它
# 就会自动执行Request对象的callback方法，爬去的是url参数中的链接
from scrapy.http import Request
yield Request(url=page_url,callback=self.parse) 查看全部
)
介绍
Scrapy 是一个高级的 Python 爬虫框架。它不仅收录爬虫功能，还可以方便地将爬虫数据保存为csv、json等文件。
首先我们安装 Scrapy。
它可用于数据挖掘、信息处理或存储历史数据等一系列程序中。它最初是为网页抓取（更准确地说，网页抓取）而设计的，但也可用于检索 API（例如 Amazon Associates Web 服务）或通用网络爬虫返回的数据。Scrapy 用途广泛，可用于数据挖掘、监控和自动化测试。
Scrapy 使用 Twisted 异步网络库来处理网络通信。整体结构大致如下
安装 linux 或 mac
pip3 install scrapy
视窗
#下载twisted
http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
#安装wheel模块之后才能安装.whl文件
pip3 install wheel
#安装twisted
pip install Twisted‑18.4.0‑cp36‑cp36m‑win_amd64.whl
pip3 install pywin32
#安装scrapy
pip3 install scrapy
使用创建项目
格式：scrapy startproject 项目名称
scrapy startproject spider
项目创建后会生成一个目录，如下：
项目名称/
- spiders # 爬虫文件
- chouti.py
- cnblgos.py
....
- items.py # 持久化
- pipelines # 持久化
- middlewares.py # 中间件
- settings.py # 配置文件（爬虫）
scrapy.cfg # 配置文件（部署）
创建爬虫
格式：
cd 项目名称
scrapy genspider 爬虫名称将被爬取 网站
cd spider
scrapy genspider chouti chouti.com
爬虫创建后会在spiders文件夹下生成一个文件
打开chouti.py后如下：
运行爬虫
scrapy crawl chouti
scrapy crawl chouti --nolog # 不打印日志
例子
# -*- coding: utf-8 -*-
import scrapy
class ChoutiSpider(scrapy.Spider):
'''
爬去抽屉网的帖子信息
'''
name = 'chouti'
allowed_domains = ['chouti.com']
start_urls = ['http://chouti.com/']
def parse(self, response):
# 获取帖子列表的父级div
content_div = response.xpath('//div[@id="content-list"]')
# 获取帖子item的列表
items_list = content_div.xpath('.//div[@class="item"]')
# 打开一个文件句柄，目的是为了将获取的东西写入文件
with open('articles.log','a+',encoding='utf-8') as f:
# 循环item_list
for item in items_list:
# 获取每个item的第一个a标签的文本和url链接
text = item.xpath('.//a/text()').extract_first()
href = item.xpath('.//a/@href').extract_first()
# print(href, text.strip())
# print('-'*100)
f.write(href+'\n')
f.write(text.strip()+'\n')
f.write('-'*100+'\n')
# 获取分页的页码，然后让程序循环爬去每个链接
# 页码标签对象列表
page_list = response.xpath('//div[@id="dig_lcpage"]')
# 循环列表
for page in page_list:
# 获取每个标签下的a标签的url，即每页的链接
page_a_url = page.xpath('.//a/@href').extract()
# 将域名和url拼接起来
page_url = 'https://dig.chouti.com' + page_a_url
# 重要的一步！！！！
# 导入Request模块，然后实例化一个Request对象，然后yield它
# 就会自动执行Request对象的callback方法，爬去的是url参数中的链接
from scrapy.http import Request
yield Request(url=page_url,callback=self.parse) 查看全部
scrapy分页抓取网页(Scrapy高级Python爬虫框架
)
介绍
Scrapy 是一个高级的 Python 爬虫框架。它不仅收录爬虫功能，还可以方便地将爬虫数据保存为csv、json等文件。
首先我们安装 Scrapy。
它可用于数据挖掘、信息处理或存储历史数据等一系列程序中。它最初是为网页抓取（更准确地说，网页抓取）而设计的，但也可用于检索 API（例如 Amazon Associates Web 服务）或通用网络爬虫返回的数据。Scrapy 用途广泛，可用于数据挖掘、监控和自动化测试。
Scrapy 使用 Twisted 异步网络库来处理网络通信。整体结构大致如下
安装 linux 或 mac
pip3 install scrapy
视窗
#下载twisted
http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
#安装wheel模块之后才能安装.whl文件
pip3 install wheel
#安装twisted
pip install Twisted‑18.4.0‑cp36‑cp36m‑win_amd64.whl
pip3 install pywin32
#安装scrapy
pip3 install scrapy
使用创建项目
格式：scrapy startproject 项目名称
scrapy startproject spider
项目创建后会生成一个目录，如下：
项目名称/
- spiders # 爬虫文件
- chouti.py
- cnblgos.py
....
- items.py # 持久化
- pipelines # 持久化
- middlewares.py # 中间件
- settings.py # 配置文件（爬虫）
scrapy.cfg # 配置文件（部署）
创建爬虫
格式：
cd 项目名称
scrapy genspider 爬虫名称将被爬取 网站
cd spider
scrapy genspider chouti chouti.com
爬虫创建后会在spiders文件夹下生成一个文件
打开chouti.py后如下：
运行爬虫
scrapy crawl chouti
scrapy crawl chouti --nolog # 不打印日志
例子
# -*- coding: utf-8 -*-
import scrapy
class ChoutiSpider(scrapy.Spider):
'''
爬去抽屉网的帖子信息
'''
name = 'chouti'
allowed_domains = ['chouti.com']
start_urls = ['http://chouti.com/']
def parse(self, response):
# 获取帖子列表的父级div
content_div = response.xpath('//div[@id="content-list"]')
# 获取帖子item的列表
items_list = content_div.xpath('.//div[@class="item"]')
# 打开一个文件句柄，目的是为了将获取的东西写入文件
with open('articles.log','a+',encoding='utf-8') as f:
# 循环item_list
for item in items_list:
# 获取每个item的第一个a标签的文本和url链接
text = item.xpath('.//a/text()').extract_first()
href = item.xpath('.//a/@href').extract_first()
# print(href, text.strip())
# print('-'*100)
f.write(href+'\n')
f.write(text.strip()+'\n')
f.write('-'*100+'\n')
# 获取分页的页码，然后让程序循环爬去每个链接
# 页码标签对象列表
page_list = response.xpath('//div[@id="dig_lcpage"]')
# 循环列表
for page in page_list:
# 获取每个标签下的a标签的url，即每页的链接
page_a_url = page.xpath('.//a/@href').extract()
# 将域名和url拼接起来
page_url = 'https://dig.chouti.com' + page_a_url
# 重要的一步！！！！
# 导入Request模块，然后实例化一个Request对象，然后yield它
# 就会自动执行Request对象的callback方法，爬去的是url参数中的链接
from scrapy.http import Request
yield Request(url=page_url,callback=self.parse)
scrapy分页抓取网页(Python大火，为了跟上时代，试着自学了下某位作者)
网站优化 • 优采云 发表了文章 • 0 个评论 • 51 次浏览 • 2022-02-07 12:20
scrapy分页抓取网页(Python大火，为了跟上时代，试着自学了下某位作者)
Python 最近火了一把。为了跟上时代的步伐，我试着自学。Scrapy 是一个高级的 Python 爬虫框架，不仅收录爬虫功能，还可以方便地将爬虫数据保存为 csv、json 等文件。
今天我们将尝试使用Scrapy爬取简书某作者的所有文章。
在本教程中，我们假设您已经安装了 Scrapy。如果没有，请参考。
1.创建项目
在开始爬取之前，我们必须新建一个 Scrapy 项目，我这里命名为 jianshu_article。打开 Mac 终端，cd 到您要存储代码的目录，然后运行以下命令：
//Mac终端运行如下命令：
scrapy startproject jianshu_article
2.创建爬虫
//cd到上面创建的文件目录
cd jianshu_article
//创建爬虫程序
scrapy genspider jianshu jianshu.com
/*
文件说明：
scrapy.cfg 项目的配置信息，主要为Scrapy命令行工具提供一个基础的配置信息。（真正爬虫相关的配置信息在settings.py文件中）
items.py 设置数据存储模型，用于结构化数据，如：Django的Model
pipelines 数据处理行为，如：一般结构化的数据持久化
settings.py 配置文件，如：USER_AGENT(模拟浏览器，应对网站反爬)，递归的层数、并发数，延迟下载等
spiders 爬虫目录，如：创建文件，编写爬虫规则
*/
为了方便编写程序，我们使用Pycharm打开项目。执行上述命令后，程序会自动创建目录和文件，这会生成一个 jianshu.py 文件，后面我们的主要逻辑会写在这个文件中。
简书.py
3.设置数据模型
双击 items.py 文件。
找到你要爬取的作者主页，比如我自己的主页，用谷歌浏览器打开，在空白处右键，点击“勾选”进入控制台开发者模式：
打开控制台.png
通过分析网页的源代码，我们大概需要以下内容：
# -*- coding: utf-8 -*-
# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html
import scrapy
class JianshuArticalItem(scrapy.Item):
avatar = scrapy.Field() #头像
nickname = scrapy.Field() #昵称
time = scrapy.Field() #发表时间
wrap_img = scrapy.Field() #封面（缺省值）
title = scrapy.Field() #标题
abstract = scrapy.Field() #正文部分显示
read = scrapy.Field() #查看人数
comments = scrapy.Field() #评论数
like = scrapy.Field() #喜欢（点赞）
detail = scrapy.Field() #文章详情url
pass
这样，数据模型就创建好了，以后我运行爬虫的时候，我得到的数据会存放在模型对应的位置。
4.分析网页源码，编写爬虫
因为我比较懒，很少写文章，而且文章的数量比较少，为了显示分页的效果，我选择了作者CC老师_MissCC的主页在简书爬取。
我们可以通过分析 URL 找到一些特征：
作者的网址是：+作者ID：
作者主页 URL.png
文章 的 URL 为：+ 文章ID：
文章网址.png
虽然我们直接在浏览器中打开作者的 URL，但是用鼠标滚轮向下滚动会动态加载下一页，直到最后一个 文章URL 保持不变。但是作为一个Scrapy爬虫，好像只能拿到首页，那怎么办呢？根据我个人多年的开发经验，尝试在URL后面拼接一个“page”参数加上页数。果然，我可以请求不同的数据。
拼接参数页面获取分页数据.png
找到这些规则，我们可以通过分析HTML源代码得到我们想要的数据。
首先，我们回到 jianshu.py 文件，导入模型：
//从项目名 jianshu_article的文件items.py导入JianshuArticleItem类
from jianshu_article.items import JianshuArticleItem
设置必要的参数以启动第一个请求：
# -*- coding: utf-8 -*-
import scrapy
from jianshu_article.items import JianshuArticleItem
class JianshuSpider(scrapy.Spider):
name = 'jianshu'
allowed_domains = ['jianshu.com']
user_id = "1b4c832fb2ca"
url = "https://www.jianshu.com/u/{0}?page=1".format(user_id)
start_urls = [
url,
]
def parse(self, response):
#用户头像
c = response.xpath('//div[@class="main-top"]/a[@class="avatar"]/img/@src').extract_first()
print(c)
pass
此时终端运行命令scrapy crawl jianshu，理论上可以打印网页内容。其实并没有请求数据，终端会打印一些日志信息：
日志.png
不难发现，403问题和HTTP状态码未处理或不允许问题导致“Closing spider (finished)”爬虫终止。通过万能的百度知道，大概是网站采取了一些相应的防爬虫措施造成的。对症下药，我们只需要在settings.py中做一些相应的修改：
```
User_Agent中文名为用户代理，简称 UA，它是一个特殊字符串头，使得服务器能够识别客户使用的
操作系统及版本、CPU 类型、浏览器及版本、浏览器渲染引擎、浏览器语言、浏览器插件等。
通俗点讲，我们配置这个字段的目的就是为了伪装成浏览器打开网页，达到骗过目标网站的监测。
```
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.186 Safari/537.36'
CONCURRENT_REQUESTS = 1 #并发数
DOWNLOAD_DELAY = 5 #为了防止IP被封，我们5秒请求一次
HTTPERROR_ALLOWED_CODES = [403] #上面报的是403，就把403加入
#默认为True，就是要遵守robots.txt 的规则，这里我们改为False
ROBOTSTXT_OBEY = False
进行相应修改后，我们再次执行爬虫命令：scrapy crawl jianshu，查看日志打印获取头像。
获取头像.png
既然可以成功爬取网页数据，那么我们后面要做的就是分析网页的源代码。当然，在这之前你得对xpath有一定的了解。
以下是对Scrapy中文官网的介绍：
有很多方法可以从网页中提取数据。Scrapy 使用基于 XPath 和 CSS 表达式的机制：. 有关选择器和其他提取机制的信息，请参见此处。
以下是 XPath 表达式及其对应含义的示例：
以上只是几个简单的 XPath 示例，XPath 实际上远比这强大。如果您想了解更多信息，我们推荐此 XPath 教程。
通过上面的介绍，相信你可以做好接下来的爬虫工作了，把jianshu.py的所有代码贴在下面，供参考：
# -*- coding: utf-8 -*-
import scrapy
from jianshu_article.items import JianshuArticleItem
class JianshuSpider(scrapy.Spider):
name = 'jianshu'
allowed_domains = ['jianshu.com']
user_id = "1b4c832fb2ca" #替换此用户ID可获取你需要的数据，或者放开下一行的注释
#user_id = input('请输入作者id：\n')
url = "https://www.jianshu.com/u/{0}?page=1".format(user_id)
start_urls = [
url,
]
def parse(self, response):
# [关注,粉丝,文章]
a = response.xpath('//div[@class="main-top"]/div[@class="info"]/ul/li/div/a/p/text()').extract()
print(a)
# [字数,收获喜欢]
b = response.xpath('//div[@class="main-top"]/div[@class="info"]/ul/li/div/p/text()').extract()
print(b)
# 大头像
c = response.xpath('//div[@class="main-top"]/a[@class="avatar"]/img/@src').extract_first()
print(c)
# 用户名
d = response.xpath('//div[@class="main-top"]/div[@class="title"]/a/text()').extract_first()
print(d)
# 性别
e = response.xpath('//div[@class="main-top"]/div[@class="title"]/i/@class').extract_first()
print(e)
# 获取文章总数，计算页数。（简书网站默认每页是9组数据）
temp = int(a[2])
if (temp % 9 > 0):
count = temp // 9 + 1
else:
count = temp // 9
print("总共" + str(count) + "页")
base_url = "https://www.jianshu.com/u/{0}?page={1}"
for i in range(1, count + 1):
i = count + 1 - i #理论上正序1~count就是按顺序获取的，但是获取的数据是倒置的，所以我们获取count~1的数据，得到的数组就是按照网页形式1~count页码排序的了
yield scrapy.Request(base_url.format(self.user_id, i), dont_filter=True, callback=self.parse_page)
#迭代返回每页的内容
def parse_page(self, response):
for sel in response.xpath('//div[@id="list-container"]/ul/li'):
item = JianshuArticleItem()
item['wrap_img'] = sel.xpath('a/img/@src').extract_first()
item['avatar'] = sel.xpath('div//a[@class="avatar"]/img/@src').extract_first()
item['nickname'] = sel.xpath('div//a[@class="nickname"]/text()').extract_first()
item['time'] = sel.xpath('div//span[@class="time"]/@data-shared-at').extract_first()
item['title'] = sel.xpath('div/a[@class="title"]/text()').extract_first()
item['abstract'] = sel.xpath('div/p[@class="abstract"]/text()').extract_first()
item['read'] = sel.xpath('div/div[@class="meta"]/a[1]/text()').extract()[1]
item['comments'] = sel.xpath('div/div[@class="meta"]/a[2]/text()').extract()[1]
item['like'] = sel.xpath('div/div[@class="meta"]/span/text()').extract_first()
item['detail'] = sel.xpath('div/a[@class="title"]/@href').extract_first()
yield item
至此，爬虫代码就写好了。如果要保存获取的数据，可以在终端执行以下命令：
/*
此命令用于把爬取的数据保存为json文件格式，当然你也可以保存为别的文件格式。
Scrapy官方列出的文件格式有如下几种：('json', 'jsonlines', 'jl', 'csv', 'xml', 'marshal', 'pickle')。
温馨提示：如果要再次爬取，最好换一个文件名或者清空数据再爬取，因为第二还是写入上一个文件，数据不会覆盖，
会堆积在上次获取的下面，造成json文件格式报错。
*/
scrapy crawl jianshu -o data.json
程序执行后，我们可以在文件目录下看到新生成的data.json文件，双击可以看到我们想要获取的所有数据：
执行crawler.png获取的数据
json解析数据和网站.png上的一模一样
github地址： 查看全部
Python 最近火了一把。为了跟上时代的步伐，我试着自学。Scrapy 是一个高级的 Python 爬虫框架，不仅收录爬虫功能，还可以方便地将爬虫数据保存为 csv、json 等文件。
今天我们将尝试使用Scrapy爬取简书某作者的所有文章。
在本教程中，我们假设您已经安装了 Scrapy。如果没有，请参考。
1.创建项目
在开始爬取之前，我们必须新建一个 Scrapy 项目，我这里命名为 jianshu_article。打开 Mac 终端，cd 到您要存储代码的目录，然后运行以下命令：
//Mac终端运行如下命令：
scrapy startproject jianshu_article
2.创建爬虫
//cd到上面创建的文件目录
cd jianshu_article
//创建爬虫程序
scrapy genspider jianshu jianshu.com
/*
文件说明：
scrapy.cfg 项目的配置信息，主要为Scrapy命令行工具提供一个基础的配置信息。（真正爬虫相关的配置信息在settings.py文件中）
items.py 设置数据存储模型，用于结构化数据，如：Django的Model
pipelines 数据处理行为，如：一般结构化的数据持久化
settings.py 配置文件，如：USER_AGENT(模拟浏览器，应对网站反爬)，递归的层数、并发数，延迟下载等
spiders 爬虫目录，如：创建文件，编写爬虫规则
*/
为了方便编写程序，我们使用Pycharm打开项目。执行上述命令后，程序会自动创建目录和文件，这会生成一个 jianshu.py 文件，后面我们的主要逻辑会写在这个文件中。
简书.py
3.设置数据模型
双击 items.py 文件。
找到你要爬取的作者主页，比如我自己的主页，用谷歌浏览器打开，在空白处右键，点击“勾选”进入控制台开发者模式：
打开控制台.png
通过分析网页的源代码，我们大概需要以下内容：
# -*- coding: utf-8 -*-
# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html
import scrapy
class JianshuArticalItem(scrapy.Item):
avatar = scrapy.Field() #头像
nickname = scrapy.Field() #昵称
time = scrapy.Field() #发表时间
wrap_img = scrapy.Field() #封面（缺省值）
title = scrapy.Field() #标题
abstract = scrapy.Field() #正文部分显示
read = scrapy.Field() #查看人数
comments = scrapy.Field() #评论数
like = scrapy.Field() #喜欢（点赞）
detail = scrapy.Field() #文章详情url
pass
这样，数据模型就创建好了，以后我运行爬虫的时候，我得到的数据会存放在模型对应的位置。
4.分析网页源码，编写爬虫
因为我比较懒，很少写文章，而且文章的数量比较少，为了显示分页的效果，我选择了作者CC老师_MissCC的主页在简书爬取。
我们可以通过分析 URL 找到一些特征：
作者的网址是：+作者ID：
作者主页 URL.png
文章 的 URL 为：+ 文章ID：
文章网址.png
虽然我们直接在浏览器中打开作者的 URL，但是用鼠标滚轮向下滚动会动态加载下一页，直到最后一个 文章URL 保持不变。但是作为一个Scrapy爬虫，好像只能拿到首页，那怎么办呢？根据我个人多年的开发经验，尝试在URL后面拼接一个“page”参数加上页数。果然，我可以请求不同的数据。
拼接参数页面获取分页数据.png
找到这些规则，我们可以通过分析HTML源代码得到我们想要的数据。
首先，我们回到 jianshu.py 文件，导入模型：
//从项目名 jianshu_article的文件items.py导入JianshuArticleItem类
from jianshu_article.items import JianshuArticleItem
设置必要的参数以启动第一个请求：
# -*- coding: utf-8 -*-
import scrapy
from jianshu_article.items import JianshuArticleItem
class JianshuSpider(scrapy.Spider):
name = 'jianshu'
allowed_domains = ['jianshu.com']
user_id = "1b4c832fb2ca"
url = "https://www.jianshu.com/u/{0}?page=1".format(user_id)
start_urls = [
url,
]
def parse(self, response):
#用户头像
c = response.xpath('//div[@class="main-top"]/a[@class="avatar"]/img/@src').extract_first()
print(c)
pass
此时终端运行命令scrapy crawl jianshu，理论上可以打印网页内容。其实并没有请求数据，终端会打印一些日志信息：
日志.png
不难发现，403问题和HTTP状态码未处理或不允许问题导致“Closing spider (finished)”爬虫终止。通过万能的百度知道，大概是网站采取了一些相应的防爬虫措施造成的。对症下药，我们只需要在settings.py中做一些相应的修改：
```
User_Agent中文名为用户代理，简称 UA，它是一个特殊字符串头，使得服务器能够识别客户使用的
操作系统及版本、CPU 类型、浏览器及版本、浏览器渲染引擎、浏览器语言、浏览器插件等。
通俗点讲，我们配置这个字段的目的就是为了伪装成浏览器打开网页，达到骗过目标网站的监测。
```
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.186 Safari/537.36'
CONCURRENT_REQUESTS = 1 #并发数
DOWNLOAD_DELAY = 5 #为了防止IP被封，我们5秒请求一次
HTTPERROR_ALLOWED_CODES = [403] #上面报的是403，就把403加入
#默认为True，就是要遵守robots.txt 的规则，这里我们改为False
ROBOTSTXT_OBEY = False
进行相应修改后，我们再次执行爬虫命令：scrapy crawl jianshu，查看日志打印获取头像。
获取头像.png
既然可以成功爬取网页数据，那么我们后面要做的就是分析网页的源代码。当然，在这之前你得对xpath有一定的了解。
以下是对Scrapy中文官网的介绍：
有很多方法可以从网页中提取数据。Scrapy 使用基于 XPath 和 CSS 表达式的机制：. 有关选择器和其他提取机制的信息，请参见此处。
以下是 XPath 表达式及其对应含义的示例：
以上只是几个简单的 XPath 示例，XPath 实际上远比这强大。如果您想了解更多信息，我们推荐此 XPath 教程。
通过上面的介绍，相信你可以做好接下来的爬虫工作了，把jianshu.py的所有代码贴在下面，供参考：
# -*- coding: utf-8 -*-
import scrapy
from jianshu_article.items import JianshuArticleItem
class JianshuSpider(scrapy.Spider):
name = 'jianshu'
allowed_domains = ['jianshu.com']
user_id = "1b4c832fb2ca" #替换此用户ID可获取你需要的数据，或者放开下一行的注释
#user_id = input('请输入作者id：\n')
url = "https://www.jianshu.com/u/{0}?page=1".format(user_id)
start_urls = [
url,
]
def parse(self, response):
# [关注,粉丝,文章]
a = response.xpath('//div[@class="main-top"]/div[@class="info"]/ul/li/div/a/p/text()').extract()
print(a)
# [字数,收获喜欢]
b = response.xpath('//div[@class="main-top"]/div[@class="info"]/ul/li/div/p/text()').extract()
print(b)
# 大头像
c = response.xpath('//div[@class="main-top"]/a[@class="avatar"]/img/@src').extract_first()
print(c)
# 用户名
d = response.xpath('//div[@class="main-top"]/div[@class="title"]/a/text()').extract_first()
print(d)
# 性别
e = response.xpath('//div[@class="main-top"]/div[@class="title"]/i/@class').extract_first()
print(e)
# 获取文章总数，计算页数。（简书网站默认每页是9组数据）
temp = int(a[2])
if (temp % 9 > 0):
count = temp // 9 + 1
else:
count = temp // 9
print("总共" + str(count) + "页")
base_url = "https://www.jianshu.com/u/{0}?page={1}"
for i in range(1, count + 1):
i = count + 1 - i #理论上正序1~count就是按顺序获取的，但是获取的数据是倒置的，所以我们获取count~1的数据，得到的数组就是按照网页形式1~count页码排序的了
yield scrapy.Request(base_url.format(self.user_id, i), dont_filter=True, callback=self.parse_page)
#迭代返回每页的内容
def parse_page(self, response):
for sel in response.xpath('//div[@id="list-container"]/ul/li'):
item = JianshuArticleItem()
item['wrap_img'] = sel.xpath('a/img/@src').extract_first()
item['avatar'] = sel.xpath('div//a[@class="avatar"]/img/@src').extract_first()
item['nickname'] = sel.xpath('div//a[@class="nickname"]/text()').extract_first()
item['time'] = sel.xpath('div//span[@class="time"]/@data-shared-at').extract_first()
item['title'] = sel.xpath('div/a[@class="title"]/text()').extract_first()
item['abstract'] = sel.xpath('div/p[@class="abstract"]/text()').extract_first()
item['read'] = sel.xpath('div/div[@class="meta"]/a[1]/text()').extract()[1]
item['comments'] = sel.xpath('div/div[@class="meta"]/a[2]/text()').extract()[1]
item['like'] = sel.xpath('div/div[@class="meta"]/span/text()').extract_first()
item['detail'] = sel.xpath('div/a[@class="title"]/@href').extract_first()
yield item
至此，爬虫代码就写好了。如果要保存获取的数据，可以在终端执行以下命令：
/*
此命令用于把爬取的数据保存为json文件格式，当然你也可以保存为别的文件格式。
Scrapy官方列出的文件格式有如下几种：('json', 'jsonlines', 'jl', 'csv', 'xml', 'marshal', 'pickle')。
温馨提示：如果要再次爬取，最好换一个文件名或者清空数据再爬取，因为第二还是写入上一个文件，数据不会覆盖，
会堆积在上次获取的下面，造成json文件格式报错。
*/
scrapy crawl jianshu -o data.json
程序执行后，我们可以在文件目录下看到新生成的data.json文件，双击可以看到我们想要获取的所有数据：
执行crawler.png获取的数据
json解析数据和网站.png上的一模一样
github地址： 查看全部
scrapy分页抓取网页(Python大火，为了跟上时代，试着自学了下某位作者)
Python 最近火了一把。为了跟上时代的步伐，我试着自学。Scrapy 是一个高级的 Python 爬虫框架，不仅收录爬虫功能，还可以方便地将爬虫数据保存为 csv、json 等文件。
今天我们将尝试使用Scrapy爬取简书某作者的所有文章。
在本教程中，我们假设您已经安装了 Scrapy。如果没有，请参考。
1.创建项目
在开始爬取之前，我们必须新建一个 Scrapy 项目，我这里命名为 jianshu_article。打开 Mac 终端，cd 到您要存储代码的目录，然后运行以下命令：
//Mac终端运行如下命令：
scrapy startproject jianshu_article
2.创建爬虫
//cd到上面创建的文件目录
cd jianshu_article
//创建爬虫程序
scrapy genspider jianshu jianshu.com
/*
文件说明：
scrapy.cfg 项目的配置信息，主要为Scrapy命令行工具提供一个基础的配置信息。（真正爬虫相关的配置信息在settings.py文件中）
items.py 设置数据存储模型，用于结构化数据，如：Django的Model
pipelines 数据处理行为，如：一般结构化的数据持久化
settings.py 配置文件，如：USER_AGENT(模拟浏览器，应对网站反爬)，递归的层数、并发数，延迟下载等
spiders 爬虫目录，如：创建文件，编写爬虫规则
*/
为了方便编写程序，我们使用Pycharm打开项目。执行上述命令后，程序会自动创建目录和文件，这会生成一个 jianshu.py 文件，后面我们的主要逻辑会写在这个文件中。
简书.py
3.设置数据模型
双击 items.py 文件。
找到你要爬取的作者主页，比如我自己的主页，用谷歌浏览器打开，在空白处右键，点击“勾选”进入控制台开发者模式：
打开控制台.png
通过分析网页的源代码，我们大概需要以下内容：
# -*- coding: utf-8 -*-
# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html
import scrapy
class JianshuArticalItem(scrapy.Item):
avatar = scrapy.Field() #头像
nickname = scrapy.Field() #昵称
time = scrapy.Field() #发表时间
wrap_img = scrapy.Field() #封面（缺省值）
title = scrapy.Field() #标题
abstract = scrapy.Field() #正文部分显示
read = scrapy.Field() #查看人数
comments = scrapy.Field() #评论数
like = scrapy.Field() #喜欢（点赞）
detail = scrapy.Field() #文章详情url
pass
这样，数据模型就创建好了，以后我运行爬虫的时候，我得到的数据会存放在模型对应的位置。
4.分析网页源码，编写爬虫
因为我比较懒，很少写文章，而且文章的数量比较少，为了显示分页的效果，我选择了作者CC老师_MissCC的主页在简书爬取。
我们可以通过分析 URL 找到一些特征：
作者的网址是：+作者ID：
作者主页 URL.png
文章 的 URL 为：+ 文章ID：
文章网址.png
虽然我们直接在浏览器中打开作者的 URL，但是用鼠标滚轮向下滚动会动态加载下一页，直到最后一个 文章URL 保持不变。但是作为一个Scrapy爬虫，好像只能拿到首页，那怎么办呢？根据我个人多年的开发经验，尝试在URL后面拼接一个“page”参数加上页数。果然，我可以请求不同的数据。
拼接参数页面获取分页数据.png
找到这些规则，我们可以通过分析HTML源代码得到我们想要的数据。
首先，我们回到 jianshu.py 文件，导入模型：
//从项目名 jianshu_article的文件items.py导入JianshuArticleItem类
from jianshu_article.items import JianshuArticleItem
设置必要的参数以启动第一个请求：
# -*- coding: utf-8 -*-
import scrapy
from jianshu_article.items import JianshuArticleItem
class JianshuSpider(scrapy.Spider):
name = 'jianshu'
allowed_domains = ['jianshu.com']
user_id = "1b4c832fb2ca"
url = "https://www.jianshu.com/u/{0}?page=1".format(user_id)
start_urls = [
url,
]
def parse(self, response):
#用户头像
c = response.xpath('//div[@class="main-top"]/a[@class="avatar"]/img/@src').extract_first()
print(c)
pass
此时终端运行命令scrapy crawl jianshu，理论上可以打印网页内容。其实并没有请求数据，终端会打印一些日志信息：
日志.png
不难发现，403问题和HTTP状态码未处理或不允许问题导致“Closing spider (finished)”爬虫终止。通过万能的百度知道，大概是网站采取了一些相应的防爬虫措施造成的。对症下药，我们只需要在settings.py中做一些相应的修改：
```
User_Agent中文名为用户代理，简称 UA，它是一个特殊字符串头，使得服务器能够识别客户使用的
操作系统及版本、CPU 类型、浏览器及版本、浏览器渲染引擎、浏览器语言、浏览器插件等。
通俗点讲，我们配置这个字段的目的就是为了伪装成浏览器打开网页，达到骗过目标网站的监测。
```
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.186 Safari/537.36'
CONCURRENT_REQUESTS = 1 #并发数
DOWNLOAD_DELAY = 5 #为了防止IP被封，我们5秒请求一次
HTTPERROR_ALLOWED_CODES = [403] #上面报的是403，就把403加入
#默认为True，就是要遵守robots.txt 的规则，这里我们改为False
ROBOTSTXT_OBEY = False
进行相应修改后，我们再次执行爬虫命令：scrapy crawl jianshu，查看日志打印获取头像。
获取头像.png
既然可以成功爬取网页数据，那么我们后面要做的就是分析网页的源代码。当然，在这之前你得对xpath有一定的了解。
以下是对Scrapy中文官网的介绍：
有很多方法可以从网页中提取数据。Scrapy 使用基于 XPath 和 CSS 表达式的机制：. 有关选择器和其他提取机制的信息，请参见此处。
以下是 XPath 表达式及其对应含义的示例：
以上只是几个简单的 XPath 示例，XPath 实际上远比这强大。如果您想了解更多信息，我们推荐此 XPath 教程。
通过上面的介绍，相信你可以做好接下来的爬虫工作了，把jianshu.py的所有代码贴在下面，供参考：
# -*- coding: utf-8 -*-
import scrapy
from jianshu_article.items import JianshuArticleItem
class JianshuSpider(scrapy.Spider):
name = 'jianshu'
allowed_domains = ['jianshu.com']
user_id = "1b4c832fb2ca" #替换此用户ID可获取你需要的数据，或者放开下一行的注释
#user_id = input('请输入作者id：\n')
url = "https://www.jianshu.com/u/{0}?page=1".format(user_id)
start_urls = [
url,
]
def parse(self, response):
# [关注,粉丝,文章]
a = response.xpath('//div[@class="main-top"]/div[@class="info"]/ul/li/div/a/p/text()').extract()
print(a)
# [字数,收获喜欢]
b = response.xpath('//div[@class="main-top"]/div[@class="info"]/ul/li/div/p/text()').extract()
print(b)
# 大头像
c = response.xpath('//div[@class="main-top"]/a[@class="avatar"]/img/@src').extract_first()
print(c)
# 用户名
d = response.xpath('//div[@class="main-top"]/div[@class="title"]/a/text()').extract_first()
print(d)
# 性别
e = response.xpath('//div[@class="main-top"]/div[@class="title"]/i/@class').extract_first()
print(e)
# 获取文章总数，计算页数。（简书网站默认每页是9组数据）
temp = int(a[2])
if (temp % 9 > 0):
count = temp // 9 + 1
else:
count = temp // 9
print("总共" + str(count) + "页")
base_url = "https://www.jianshu.com/u/{0}?page={1}"
for i in range(1, count + 1):
i = count + 1 - i #理论上正序1~count就是按顺序获取的，但是获取的数据是倒置的，所以我们获取count~1的数据，得到的数组就是按照网页形式1~count页码排序的了
yield scrapy.Request(base_url.format(self.user_id, i), dont_filter=True, callback=self.parse_page)
#迭代返回每页的内容
def parse_page(self, response):
for sel in response.xpath('//div[@id="list-container"]/ul/li'):
item = JianshuArticleItem()
item['wrap_img'] = sel.xpath('a/img/@src').extract_first()
item['avatar'] = sel.xpath('div//a[@class="avatar"]/img/@src').extract_first()
item['nickname'] = sel.xpath('div//a[@class="nickname"]/text()').extract_first()
item['time'] = sel.xpath('div//span[@class="time"]/@data-shared-at').extract_first()
item['title'] = sel.xpath('div/a[@class="title"]/text()').extract_first()
item['abstract'] = sel.xpath('div/p[@class="abstract"]/text()').extract_first()
item['read'] = sel.xpath('div/div[@class="meta"]/a[1]/text()').extract()[1]
item['comments'] = sel.xpath('div/div[@class="meta"]/a[2]/text()').extract()[1]
item['like'] = sel.xpath('div/div[@class="meta"]/span/text()').extract_first()
item['detail'] = sel.xpath('div/a[@class="title"]/@href').extract_first()
yield item
至此，爬虫代码就写好了。如果要保存获取的数据，可以在终端执行以下命令：
/*
此命令用于把爬取的数据保存为json文件格式，当然你也可以保存为别的文件格式。
Scrapy官方列出的文件格式有如下几种：('json', 'jsonlines', 'jl', 'csv', 'xml', 'marshal', 'pickle')。
温馨提示：如果要再次爬取，最好换一个文件名或者清空数据再爬取，因为第二还是写入上一个文件，数据不会覆盖，
会堆积在上次获取的下面，造成json文件格式报错。
*/
scrapy crawl jianshu -o data.json
程序执行后，我们可以在文件目录下看到新生成的data.json文件，双击可以看到我们想要获取的所有数据：
执行crawler.png获取的数据
json解析数据和网站.png上的一模一样
github地址：
scrapy分页抓取网页(如何抓取目标网站是以Js的方式动态生成数据的网页)
网站优化 • 优采云 发表了文章 • 0 个评论 • 55 次浏览 • 2022-02-07 12:14
scrapy分页抓取网页(如何抓取目标网站是以Js的方式动态生成数据的网页)
我们在爬取数据的时候，如果目标网站是以Js的方式动态生成数据，以滚动页面的方式进行分页，那我们怎么爬取呢？
如今日头条网站：
我们可以使用 Selenium 来做到这一点。虽然 Selenium 是为 Web 应用程序的自动化测试而设计的，但它非常适合数据抓取，并且可以轻松绕过 网站 的反爬虫限制，因为 Selenium 直接在浏览器中运行，就像真正的用户一样.
使用Selenium，我们不仅可以爬取Js动态生成数据的网页，还可以爬取通过滚动页面进行分页的网页。
首先，我们使用maven来导入Selenium依赖：
org.seleniumhq.selenium
selenium-java
2.47.1
然后就可以编写代码进行爬取了：
<p>import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import java.util.List;
import java.util.Random;
/**
* 如何抓取Js动态生成数据且以滚动页面方式分页的网页
* 以抓取今日头条为例说明：http://toutiao.com/
* Created by ysc on 10/13/15.
*/
public class Toutiao {
public static void main(String[] args) throws Exception{
//等待数据加载的时间
//为了防止服务器封锁，这里的时间要模拟人的行为，随机且不能太短
long waitLoadBaseTime = 3000;
int waitLoadRandomTime = 3000;
Random random = new Random(System.currentTimeMillis());
//火狐浏览器
WebDriver driver = new FirefoxDriver();
//要抓取的网页
driver.get("http://toutiao.com/");
//等待页面动态加载完毕
Thread.sleep(waitLoadBaseTime+random.nextInt(waitLoadRandomTime));
//要加载多少页数据
int pages=5;
for(int i=0; i 查看全部
我们在爬取数据的时候，如果目标网站是以Js的方式动态生成数据，以滚动页面的方式进行分页，那我们怎么爬取呢？
如今日头条网站：
我们可以使用 Selenium 来做到这一点。虽然 Selenium 是为 Web 应用程序的自动化测试而设计的，但它非常适合数据抓取，并且可以轻松绕过 网站 的反爬虫限制，因为 Selenium 直接在浏览器中运行，就像真正的用户一样.
使用Selenium，我们不仅可以爬取Js动态生成数据的网页，还可以爬取通过滚动页面进行分页的网页。
首先，我们使用maven来导入Selenium依赖：
org.seleniumhq.selenium
selenium-java
2.47.1
然后就可以编写代码进行爬取了：
<p>import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import java.util.List;
import java.util.Random;
/**
* 如何抓取Js动态生成数据且以滚动页面方式分页的网页
* 以抓取今日头条为例说明：http://toutiao.com/
* Created by ysc on 10/13/15.
*/
public class Toutiao {
public static void main(String[] args) throws Exception{
//等待数据加载的时间
//为了防止服务器封锁，这里的时间要模拟人的行为，随机且不能太短
long waitLoadBaseTime = 3000;
int waitLoadRandomTime = 3000;
Random random = new Random(System.currentTimeMillis());
//火狐浏览器
WebDriver driver = new FirefoxDriver();
//要抓取的网页
driver.get("http://toutiao.com/");
//等待页面动态加载完毕
Thread.sleep(waitLoadBaseTime+random.nextInt(waitLoadRandomTime));
//要加载多少页数据
int pages=5;
for(int i=0; i 查看全部
scrapy分页抓取网页(如何抓取目标网站是以Js的方式动态生成数据的网页)
我们在爬取数据的时候，如果目标网站是以Js的方式动态生成数据，以滚动页面的方式进行分页，那我们怎么爬取呢？
如今日头条网站：
我们可以使用 Selenium 来做到这一点。虽然 Selenium 是为 Web 应用程序的自动化测试而设计的，但它非常适合数据抓取，并且可以轻松绕过 网站 的反爬虫限制，因为 Selenium 直接在浏览器中运行，就像真正的用户一样.
使用Selenium，我们不仅可以爬取Js动态生成数据的网页，还可以爬取通过滚动页面进行分页的网页。
首先，我们使用maven来导入Selenium依赖：
org.seleniumhq.selenium
selenium-java
2.47.1
然后就可以编写代码进行爬取了：
<p>import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import java.util.List;
import java.util.Random;
/**
* 如何抓取Js动态生成数据且以滚动页面方式分页的网页
* 以抓取今日头条为例说明：http://toutiao.com/
* Created by ysc on 10/13/15.
*/
public class Toutiao {
public static void main(String[] args) throws Exception{
//等待数据加载的时间
//为了防止服务器封锁，这里的时间要模拟人的行为，随机且不能太短
long waitLoadBaseTime = 3000;
int waitLoadRandomTime = 3000;
Random random = new Random(System.currentTimeMillis());
//火狐浏览器
WebDriver driver = new FirefoxDriver();
//要抓取的网页
driver.get("http://toutiao.com/";);
//等待页面动态加载完毕
Thread.sleep(waitLoadBaseTime+random.nextInt(waitLoadRandomTime));
//要加载多少页数据
int pages=5;
for(int i=0; i
scrapy分页抓取网页(什么是Items呢？官方文档Items定义如下：Items)
网站优化 • 优采云 发表了文章 • 0 个评论 • 64 次浏览 • 2022-02-05 22:14
scrapy分页抓取网页(什么是Items呢？官方文档Items定义如下：Items)
什么是物品？官方文档Items定义如下：
项目
爬取的主要目标是从非结构化数据源中提取结构化数据，例如网页。Scrapy spider 可以使用 python 的 dict 返回提取的数据。dict虽然使用起来非常方便和熟悉，但缺乏结构，容易打错字段名或返回不一致的数据，尤其是在项目中有多个爬虫的大规模情况下。
为了定义通用的输出数据，Scrapy 提供了 Item 类。Item 对象是一个简单的容器，用于保存爬网数据。它提供了类似字典的 API 和用于声明可用字段的简单语法。
许多 Scrapy 组件使用 Item 提供的额外信息：exporter 根据 Item 声明的字段导出数据，序列化可以通过 Item 字段的元数据定义，trackref 跟踪 Item 实例以帮助查找内存泄漏（请参阅 Debugging with trackref 内存泄漏）等。
使用简单的类定义语法和 Field 对象来声明项目。我们打开scrapyspider目录下的items.py文件，编写如下代码声明Item：
import scrapy
class DoubanMovieItem(scrapy.Item):
# 排名
ranking = scrapy.Field()
# 电影名称
movie_name = scrapy.Field()
# 评分
score = scrapy.Field()
# 评论人数
score_num = scrapy.Field()
履带式
在scrapyspider/spiders目录下创建douban_spider.py文件，编写初步代码：
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
start_urls = ['https://movie.douban.com/top250']
def parse(self, response):
item = DoubanMovieItem()
这是一个基本的scrapy蜘蛛模型，首先我们需要在Scrapy.spiders中导入Spider类，以及我们刚刚在scrapyspider.items中定义的豆瓣电影项目。然后创建我们自己的爬虫类 DoubanMovieTop250Spider 并继承 Spider 类。scrapy.spiders中有很多不同的爬虫类供我们继承。一般来说，Spider类可以满足要求。（其他爬虫的使用请参考官方文档）。
蜘蛛
类scrapy.spider.Spider
蜘蛛是最简单的蜘蛛。每个其他蜘蛛都必须从这个类继承（包括 Scrapy 附带的其他蜘蛛和您自己编写的蜘蛛）。Spider 不提供任何特殊功能。它只是请求给定的 start_urls/start_requests 并根据返回的结果（结果响应）调用蜘蛛的 parse 方法。
name 定义蜘蛛名称的字符串。蜘蛛的名字定义了 Scrapy 如何定位（和初始化）蜘蛛，所以它必须是唯一的。但是，您可以在没有任何限制的情况下生成同一个蜘蛛的多个实例。name是spider最重要的属性，是必须的。
如果蜘蛛爬取单个 网站（单个域），通常的做法是在 网站（域）之后命名蜘蛛（带或不带后缀）。例如，如果蜘蛛正在爬行，蜘蛛通常会被命名为 mywebsite。
allowed_domains 是可选的。收录允许蜘蛛抓取的域列表。开启 OffsiteMiddleware 后，域名不在列表中的 URL 将不会被跟进。
start_urls URL 列表。当没有指定具体的 URL 时，蜘蛛会从这个列表开始爬取。因此，要获取的第一个页面的 URL 将是列表之一。后续 URL 将从获取的数据中提取。
start_requests() 这个方法必须返回一个可迭代的。该对象收录蜘蛛用来抓取的第一个请求。
当蜘蛛开始爬取并且没有指定 URL 时调用该方法。当指定 URL 时，将调用 make_requests_from_url() 来创建 Request 对象。此方法只会被 Scrapy 调用一次，因此您可以将其实现为生成器。
该方法的默认实现是使用 start_urls 的 url 来生成 Request。
如果要修改原来爬取了一个网站的Request对象，可以重写这个方法。例如，如果你需要在启动时 POST 到某个 网站，你可以这样写：
def start_requests(self):
return [scrapy.FormRequest("http://www.example.com/login",
formdata={'user': 'john', 'pass': 'secret'},
callback=self.logged_in)]
def logged_in(self, response):
# here you would extract links to follow and return Requests for
# each of them, with another callback
pass
make_requests_from_url(url) 该方法接受一个 URL 并返回一个请求对象进行爬取。该方法在初始化请求时被 start_requests() 调用，也用于将 url 转换为请求。
如果默认不覆盖，在该方法返回的Request对象中，parse()作为回调函数，dont_filter参数也设置为on。（详情请参阅请求）。
parse(response) 当response没有指定回调函数时，这个方法是Scrapy处理下载的response的默认方法。
parse 处理响应并返回处理后的数据和/或要遵循的 URL。Spider 对其他 Request 回调函数有相同的要求。
此方法和其他 Request 回调函数必须返回收录 Request 和/或 Item 的可迭代对象。
参数：响应（Response）——用于分析的响应
log(message[, level, component]) 使用 scrapy.log.msg() 方法记录（记录）消息。日志中自动携带蜘蛛的名称属性。有关更多数据，请参阅日志记录。
closed(reason) 这个函数在蜘蛛关闭时被调用。这个方法提供了一个快捷方式，而不是调用 signals.connect() 来监听 spider_close 信号。
提取网页信息
我们使用 xpath 语法来提取我们需要的信息。不熟悉xpath语法的同学可以在W3School网站中学习，很快就能上手。首先，我们在chrome浏览器中进入豆瓣电影TOP250页面，按F12打开开发者工具。
点击工具栏左上角类似鼠标的符号图标或Ctrl+Shift+c点击页面中我们想要的元素，在工具栏中查看其在网页HTML源代码中的位置。一般抓的时候，先抓大再抓小的原则。通过观察，我们可以看到该页面上所有电影的信息都位于一个类属性为grid_view的ol标签内的一个li标签中。
1
肖申克的救赎
/ The Shawshank Redemption
/ 月黑高飞(港) / 刺激1995(台)
[可播放]
导演: 弗兰克·德拉邦特 Frank Darabont 主演: 蒂姆·罗宾斯 Tim Robbins /...
1994 / 美国 / 犯罪 剧情
9.6
766719人评价
希望让人自由。
...
...
...
因此，我们按照上述原则爬取所需信息
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
start_urls = ['https://movie.douban.com/top250']
def parse(self, response):
item = DoubanMovieItem()
movies = response.xpath('//ol[@class="grid_view"]/li')
for movie in movies:
item['ranking'] = movie.xpath(
'.//div[@class="pic"]/em/text()').extract()[0]
item['movie_name'] = movie.xpath(
'.//div[@class="hd"]/a/span[1]/text()').extract()[0]
item['score'] = movie.xpath(
'.//div[@class="star"]/span[@class="rating_num"]/text()'
).extract()[0]
item['score_num'] = movie.xpath(
'.//div[@class="star"]/span/text()').re(ur'(\d+)人评价')[0]
yield item
Scrapy提取的页面信息内容详细请参考官方文档的相应章节。
运行爬虫
在项目文件夹中打开 cmd 并运行以下命令：
scrapy crawl douban_movie_top250 -o douban.csv
注意这里的douban_movie_top250是我们刚刚写的爬虫的名字，-o douban.csv是scrapy提供的一个快捷方式，可以将item输出为csv格式
尝试运行爬虫，为什么没有输出？！！！
在你所有的努力之后你会失败吗？！！！别着急，我们看下一个控制台输出的信息。原来是403错误。这是因为豆瓣给爬虫设置了一个很小的阈值，我们只需要在发送请求时更改请求头user-agent即可。
更改后的代码在某些地方感觉不同吗？为什么 start_urls 不见了？start_requests 函数有什么作用？还记得刚才对 Spider 类的介绍吗？让我们回过头来回顾一下上面对 start_urls 和 start_requests 函数的介绍。简单来说，通过使用start_requests函数，我们有了更多的权限来处理初始URL，比如这次在初始URL中加入了请求头user_agent。
再次运行爬虫，我们想要的信息全部下载到douban.scv文件夹中。直接用WPS打开查看信息。
自动翻页
不要太激动，没发现问题吗？在这种情况下，我们只能抓取到当前页面的 25 部电影的内容。我怎样才能和其他人一起爬下来？实现自动翻页一般有两种方式：
在页面中找到下一页的地址；根据 URL 的变化规律，自己构建所有的页面地址。
一般情况下我们使用第一种方式，第二种方式适用于页面的下一页地址是JS加载的情况。今天我们只讲第一种方法。先用Chrome浏览器的开发者工具找到下一页的地址
然后在解析页面的时候，得到下一页的地址，把地址交给调度器（Scheduler）
from scrapy import Request
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36',
}
def start_requests(self):
url = 'https://movie.douban.com/top250'
yield Request(url, headers=self.headers)
def parse(self, response):
item = DoubanMovieItem()
movies = response.xpath('//ol[@class="grid_view"]/li')
for movie in movies:
item['ranking'] = movie.xpath(
'.//div[@class="pic"]/em/text()').extract()[0]
item['movie_name'] = movie.xpath(
'.//div[@class="hd"]/a/span[1]/text()').extract()[0]
item['score'] = movie.xpath(
'.//div[@class="star"]/span[@class="rating_num"]/text()'
).extract()[0]
item['score_num'] = movie.xpath(
'.//div[@class="star"]/span/text()').re(ur'(\d+)人评价')[0]
yield item
next_url = response.xpath('//span[@class="next"]/a/@href').extract()
if next_url:
next_url = 'https://movie.douban.com/top250' + next_url[0]
yield Request(next_url, headers=self.headers)
最后再次运行爬虫，打开douban.csv。有没有发现已经获取了所有的电影信息，其中250个不超过1个，不小于250个？
最后，使用 WPS 的过滤功能，您可以过滤任何符合您要求的视频。（ps：外国和尚不总是会念经，记得用WPS打开这个CVS文件，用EXCEL打开会因为中文导致显示异常。）
结尾
自从写了这篇 Scrapy 爬虫框架教程后，我越来越觉得把学到的东西导出并没有想象中的那么简单。很多时候，在写了几个小时的教程之后，我发现我仍然无法完美地表达我想要表达的东西。如果有什么不对的地方，请纠正我。有一系列的听证会，并且有艺术行业的专业。我们都互相学习：）
源码地址：Wooden-Robot/scrapy-tutorial 查看全部
什么是物品？官方文档Items定义如下：
项目
爬取的主要目标是从非结构化数据源中提取结构化数据，例如网页。Scrapy spider 可以使用 python 的 dict 返回提取的数据。dict虽然使用起来非常方便和熟悉，但缺乏结构，容易打错字段名或返回不一致的数据，尤其是在项目中有多个爬虫的大规模情况下。
为了定义通用的输出数据，Scrapy 提供了 Item 类。Item 对象是一个简单的容器，用于保存爬网数据。它提供了类似字典的 API 和用于声明可用字段的简单语法。
许多 Scrapy 组件使用 Item 提供的额外信息：exporter 根据 Item 声明的字段导出数据，序列化可以通过 Item 字段的元数据定义，trackref 跟踪 Item 实例以帮助查找内存泄漏（请参阅 Debugging with trackref 内存泄漏）等。
使用简单的类定义语法和 Field 对象来声明项目。我们打开scrapyspider目录下的items.py文件，编写如下代码声明Item：
import scrapy
class DoubanMovieItem(scrapy.Item):
# 排名
ranking = scrapy.Field()
# 电影名称
movie_name = scrapy.Field()
# 评分
score = scrapy.Field()
# 评论人数
score_num = scrapy.Field()
履带式
在scrapyspider/spiders目录下创建douban_spider.py文件，编写初步代码：
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
start_urls = ['https://movie.douban.com/top250']
def parse(self, response):
item = DoubanMovieItem()
这是一个基本的scrapy蜘蛛模型，首先我们需要在Scrapy.spiders中导入Spider类，以及我们刚刚在scrapyspider.items中定义的豆瓣电影项目。然后创建我们自己的爬虫类 DoubanMovieTop250Spider 并继承 Spider 类。scrapy.spiders中有很多不同的爬虫类供我们继承。一般来说，Spider类可以满足要求。（其他爬虫的使用请参考官方文档）。
蜘蛛
类scrapy.spider.Spider
蜘蛛是最简单的蜘蛛。每个其他蜘蛛都必须从这个类继承（包括 Scrapy 附带的其他蜘蛛和您自己编写的蜘蛛）。Spider 不提供任何特殊功能。它只是请求给定的 start_urls/start_requests 并根据返回的结果（结果响应）调用蜘蛛的 parse 方法。
name 定义蜘蛛名称的字符串。蜘蛛的名字定义了 Scrapy 如何定位（和初始化）蜘蛛，所以它必须是唯一的。但是，您可以在没有任何限制的情况下生成同一个蜘蛛的多个实例。name是spider最重要的属性，是必须的。
如果蜘蛛爬取单个 网站（单个域），通常的做法是在 网站（域）之后命名蜘蛛（带或不带后缀）。例如，如果蜘蛛正在爬行，蜘蛛通常会被命名为 mywebsite。
allowed_domains 是可选的。收录允许蜘蛛抓取的域列表。开启 OffsiteMiddleware 后，域名不在列表中的 URL 将不会被跟进。
start_urls URL 列表。当没有指定具体的 URL 时，蜘蛛会从这个列表开始爬取。因此，要获取的第一个页面的 URL 将是列表之一。后续 URL 将从获取的数据中提取。
start_requests() 这个方法必须返回一个可迭代的。该对象收录蜘蛛用来抓取的第一个请求。
当蜘蛛开始爬取并且没有指定 URL 时调用该方法。当指定 URL 时，将调用 make_requests_from_url() 来创建 Request 对象。此方法只会被 Scrapy 调用一次，因此您可以将其实现为生成器。
该方法的默认实现是使用 start_urls 的 url 来生成 Request。
如果要修改原来爬取了一个网站的Request对象，可以重写这个方法。例如，如果你需要在启动时 POST 到某个 网站，你可以这样写：
def start_requests(self):
return [scrapy.FormRequest("http://www.example.com/login",
formdata={'user': 'john', 'pass': 'secret'},
callback=self.logged_in)]
def logged_in(self, response):
# here you would extract links to follow and return Requests for
# each of them, with another callback
pass
make_requests_from_url(url) 该方法接受一个 URL 并返回一个请求对象进行爬取。该方法在初始化请求时被 start_requests() 调用，也用于将 url 转换为请求。
如果默认不覆盖，在该方法返回的Request对象中，parse()作为回调函数，dont_filter参数也设置为on。（详情请参阅请求）。
parse(response) 当response没有指定回调函数时，这个方法是Scrapy处理下载的response的默认方法。
parse 处理响应并返回处理后的数据和/或要遵循的 URL。Spider 对其他 Request 回调函数有相同的要求。
此方法和其他 Request 回调函数必须返回收录 Request 和/或 Item 的可迭代对象。
参数：响应（Response）——用于分析的响应
log(message[, level, component]) 使用 scrapy.log.msg() 方法记录（记录）消息。日志中自动携带蜘蛛的名称属性。有关更多数据，请参阅日志记录。
closed(reason) 这个函数在蜘蛛关闭时被调用。这个方法提供了一个快捷方式，而不是调用 signals.connect() 来监听 spider_close 信号。
提取网页信息
我们使用 xpath 语法来提取我们需要的信息。不熟悉xpath语法的同学可以在W3School网站中学习，很快就能上手。首先，我们在chrome浏览器中进入豆瓣电影TOP250页面，按F12打开开发者工具。
点击工具栏左上角类似鼠标的符号图标或Ctrl+Shift+c点击页面中我们想要的元素，在工具栏中查看其在网页HTML源代码中的位置。一般抓的时候，先抓大再抓小的原则。通过观察，我们可以看到该页面上所有电影的信息都位于一个类属性为grid_view的ol标签内的一个li标签中。
1
肖申克的救赎
/ The Shawshank Redemption
/ 月黑高飞(港) / 刺激1995(台)
[可播放]
导演: 弗兰克·德拉邦特 Frank Darabont 主演: 蒂姆·罗宾斯 Tim Robbins /...
1994 / 美国 / 犯罪 剧情
9.6
766719人评价
希望让人自由。
...
...
...
因此，我们按照上述原则爬取所需信息
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
start_urls = ['https://movie.douban.com/top250']
def parse(self, response):
item = DoubanMovieItem()
movies = response.xpath('//ol[@class="grid_view"]/li')
for movie in movies:
item['ranking'] = movie.xpath(
'.//div[@class="pic"]/em/text()').extract()[0]
item['movie_name'] = movie.xpath(
'.//div[@class="hd"]/a/span[1]/text()').extract()[0]
item['score'] = movie.xpath(
'.//div[@class="star"]/span[@class="rating_num"]/text()'
).extract()[0]
item['score_num'] = movie.xpath(
'.//div[@class="star"]/span/text()').re(ur'(\d+)人评价')[0]
yield item
Scrapy提取的页面信息内容详细请参考官方文档的相应章节。
运行爬虫
在项目文件夹中打开 cmd 并运行以下命令：
scrapy crawl douban_movie_top250 -o douban.csv
注意这里的douban_movie_top250是我们刚刚写的爬虫的名字，-o douban.csv是scrapy提供的一个快捷方式，可以将item输出为csv格式
尝试运行爬虫，为什么没有输出？！！！
在你所有的努力之后你会失败吗？！！！别着急，我们看下一个控制台输出的信息。原来是403错误。这是因为豆瓣给爬虫设置了一个很小的阈值，我们只需要在发送请求时更改请求头user-agent即可。
更改后的代码在某些地方感觉不同吗？为什么 start_urls 不见了？start_requests 函数有什么作用？还记得刚才对 Spider 类的介绍吗？让我们回过头来回顾一下上面对 start_urls 和 start_requests 函数的介绍。简单来说，通过使用start_requests函数，我们有了更多的权限来处理初始URL，比如这次在初始URL中加入了请求头user_agent。
再次运行爬虫，我们想要的信息全部下载到douban.scv文件夹中。直接用WPS打开查看信息。
自动翻页
不要太激动，没发现问题吗？在这种情况下，我们只能抓取到当前页面的 25 部电影的内容。我怎样才能和其他人一起爬下来？实现自动翻页一般有两种方式：
在页面中找到下一页的地址；根据 URL 的变化规律，自己构建所有的页面地址。
一般情况下我们使用第一种方式，第二种方式适用于页面的下一页地址是JS加载的情况。今天我们只讲第一种方法。先用Chrome浏览器的开发者工具找到下一页的地址
然后在解析页面的时候，得到下一页的地址，把地址交给调度器（Scheduler）
from scrapy import Request
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36',
}
def start_requests(self):
url = 'https://movie.douban.com/top250'
yield Request(url, headers=self.headers)
def parse(self, response):
item = DoubanMovieItem()
movies = response.xpath('//ol[@class="grid_view"]/li')
for movie in movies:
item['ranking'] = movie.xpath(
'.//div[@class="pic"]/em/text()').extract()[0]
item['movie_name'] = movie.xpath(
'.//div[@class="hd"]/a/span[1]/text()').extract()[0]
item['score'] = movie.xpath(
'.//div[@class="star"]/span[@class="rating_num"]/text()'
).extract()[0]
item['score_num'] = movie.xpath(
'.//div[@class="star"]/span/text()').re(ur'(\d+)人评价')[0]
yield item
next_url = response.xpath('//span[@class="next"]/a/@href').extract()
if next_url:
next_url = 'https://movie.douban.com/top250' + next_url[0]
yield Request(next_url, headers=self.headers)
最后再次运行爬虫，打开douban.csv。有没有发现已经获取了所有的电影信息，其中250个不超过1个，不小于250个？
最后，使用 WPS 的过滤功能，您可以过滤任何符合您要求的视频。（ps：外国和尚不总是会念经，记得用WPS打开这个CVS文件，用EXCEL打开会因为中文导致显示异常。）
结尾
自从写了这篇 Scrapy 爬虫框架教程后，我越来越觉得把学到的东西导出并没有想象中的那么简单。很多时候，在写了几个小时的教程之后，我发现我仍然无法完美地表达我想要表达的东西。如果有什么不对的地方，请纠正我。有一系列的听证会，并且有艺术行业的专业。我们都互相学习：）
源码地址：Wooden-Robot/scrapy-tutorial 查看全部
scrapy分页抓取网页(什么是Items呢？官方文档Items定义如下：Items)
什么是物品？官方文档Items定义如下：
项目
爬取的主要目标是从非结构化数据源中提取结构化数据，例如网页。Scrapy spider 可以使用 python 的 dict 返回提取的数据。dict虽然使用起来非常方便和熟悉，但缺乏结构，容易打错字段名或返回不一致的数据，尤其是在项目中有多个爬虫的大规模情况下。
为了定义通用的输出数据，Scrapy 提供了 Item 类。Item 对象是一个简单的容器，用于保存爬网数据。它提供了类似字典的 API 和用于声明可用字段的简单语法。
许多 Scrapy 组件使用 Item 提供的额外信息：exporter 根据 Item 声明的字段导出数据，序列化可以通过 Item 字段的元数据定义，trackref 跟踪 Item 实例以帮助查找内存泄漏（请参阅 Debugging with trackref 内存泄漏）等。
使用简单的类定义语法和 Field 对象来声明项目。我们打开scrapyspider目录下的items.py文件，编写如下代码声明Item：
import scrapy
class DoubanMovieItem(scrapy.Item):
# 排名
ranking = scrapy.Field()
# 电影名称
movie_name = scrapy.Field()
# 评分
score = scrapy.Field()
# 评论人数
score_num = scrapy.Field()
履带式
在scrapyspider/spiders目录下创建douban_spider.py文件，编写初步代码：
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
start_urls = ['https://movie.douban.com/top250']
def parse(self, response):
item = DoubanMovieItem()
这是一个基本的scrapy蜘蛛模型，首先我们需要在Scrapy.spiders中导入Spider类，以及我们刚刚在scrapyspider.items中定义的豆瓣电影项目。然后创建我们自己的爬虫类 DoubanMovieTop250Spider 并继承 Spider 类。scrapy.spiders中有很多不同的爬虫类供我们继承。一般来说，Spider类可以满足要求。（其他爬虫的使用请参考官方文档）。
蜘蛛
类scrapy.spider.Spider
蜘蛛是最简单的蜘蛛。每个其他蜘蛛都必须从这个类继承（包括 Scrapy 附带的其他蜘蛛和您自己编写的蜘蛛）。Spider 不提供任何特殊功能。它只是请求给定的 start_urls/start_requests 并根据返回的结果（结果响应）调用蜘蛛的 parse 方法。
name 定义蜘蛛名称的字符串。蜘蛛的名字定义了 Scrapy 如何定位（和初始化）蜘蛛，所以它必须是唯一的。但是，您可以在没有任何限制的情况下生成同一个蜘蛛的多个实例。name是spider最重要的属性，是必须的。
如果蜘蛛爬取单个 网站（单个域），通常的做法是在 网站（域）之后命名蜘蛛（带或不带后缀）。例如，如果蜘蛛正在爬行，蜘蛛通常会被命名为 mywebsite。
allowed_domains 是可选的。收录允许蜘蛛抓取的域列表。开启 OffsiteMiddleware 后，域名不在列表中的 URL 将不会被跟进。
start_urls URL 列表。当没有指定具体的 URL 时，蜘蛛会从这个列表开始爬取。因此，要获取的第一个页面的 URL 将是列表之一。后续 URL 将从获取的数据中提取。
start_requests() 这个方法必须返回一个可迭代的。该对象收录蜘蛛用来抓取的第一个请求。
当蜘蛛开始爬取并且没有指定 URL 时调用该方法。当指定 URL 时，将调用 make_requests_from_url() 来创建 Request 对象。此方法只会被 Scrapy 调用一次，因此您可以将其实现为生成器。
该方法的默认实现是使用 start_urls 的 url 来生成 Request。
如果要修改原来爬取了一个网站的Request对象，可以重写这个方法。例如，如果你需要在启动时 POST 到某个 网站，你可以这样写：
def start_requests(self):
return [scrapy.FormRequest("http://www.example.com/login",
formdata={'user': 'john', 'pass': 'secret'},
callback=self.logged_in)]
def logged_in(self, response):
# here you would extract links to follow and return Requests for
# each of them, with another callback
pass
make_requests_from_url(url) 该方法接受一个 URL 并返回一个请求对象进行爬取。该方法在初始化请求时被 start_requests() 调用，也用于将 url 转换为请求。
如果默认不覆盖，在该方法返回的Request对象中，parse()作为回调函数，dont_filter参数也设置为on。（详情请参阅请求）。
parse(response) 当response没有指定回调函数时，这个方法是Scrapy处理下载的response的默认方法。
parse 处理响应并返回处理后的数据和/或要遵循的 URL。Spider 对其他 Request 回调函数有相同的要求。
此方法和其他 Request 回调函数必须返回收录 Request 和/或 Item 的可迭代对象。
参数：响应（Response）——用于分析的响应
log(message[, level, component]) 使用 scrapy.log.msg() 方法记录（记录）消息。日志中自动携带蜘蛛的名称属性。有关更多数据，请参阅日志记录。
closed(reason) 这个函数在蜘蛛关闭时被调用。这个方法提供了一个快捷方式，而不是调用 signals.connect() 来监听 spider_close 信号。
提取网页信息
我们使用 xpath 语法来提取我们需要的信息。不熟悉xpath语法的同学可以在W3School网站中学习，很快就能上手。首先，我们在chrome浏览器中进入豆瓣电影TOP250页面，按F12打开开发者工具。
点击工具栏左上角类似鼠标的符号图标或Ctrl+Shift+c点击页面中我们想要的元素，在工具栏中查看其在网页HTML源代码中的位置。一般抓的时候，先抓大再抓小的原则。通过观察，我们可以看到该页面上所有电影的信息都位于一个类属性为grid_view的ol标签内的一个li标签中。
1
肖申克的救赎
/ The Shawshank Redemption
/ 月黑高飞(港) / 刺激1995(台)
[可播放]
导演: 弗兰克·德拉邦特 Frank Darabont 主演: 蒂姆·罗宾斯 Tim Robbins /...
1994 / 美国 / 犯罪 剧情
9.6
766719人评价
希望让人自由。
...
...
...
因此，我们按照上述原则爬取所需信息
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
start_urls = ['https://movie.douban.com/top250']
def parse(self, response):
item = DoubanMovieItem()
movies = response.xpath('//ol[@class="grid_view"]/li')
for movie in movies:
item['ranking'] = movie.xpath(
'.//div[@class="pic"]/em/text()').extract()[0]
item['movie_name'] = movie.xpath(
'.//div[@class="hd"]/a/span[1]/text()').extract()[0]
item['score'] = movie.xpath(
'.//div[@class="star"]/span[@class="rating_num"]/text()'
).extract()[0]
item['score_num'] = movie.xpath(
'.//div[@class="star"]/span/text()').re(ur'(\d+)人评价')[0]
yield item
Scrapy提取的页面信息内容详细请参考官方文档的相应章节。
运行爬虫
在项目文件夹中打开 cmd 并运行以下命令：
scrapy crawl douban_movie_top250 -o douban.csv
注意这里的douban_movie_top250是我们刚刚写的爬虫的名字，-o douban.csv是scrapy提供的一个快捷方式，可以将item输出为csv格式
尝试运行爬虫，为什么没有输出？！！！
在你所有的努力之后你会失败吗？！！！别着急，我们看下一个控制台输出的信息。原来是403错误。这是因为豆瓣给爬虫设置了一个很小的阈值，我们只需要在发送请求时更改请求头user-agent即可。
更改后的代码在某些地方感觉不同吗？为什么 start_urls 不见了？start_requests 函数有什么作用？还记得刚才对 Spider 类的介绍吗？让我们回过头来回顾一下上面对 start_urls 和 start_requests 函数的介绍。简单来说，通过使用start_requests函数，我们有了更多的权限来处理初始URL，比如这次在初始URL中加入了请求头user_agent。
再次运行爬虫，我们想要的信息全部下载到douban.scv文件夹中。直接用WPS打开查看信息。
自动翻页
不要太激动，没发现问题吗？在这种情况下，我们只能抓取到当前页面的 25 部电影的内容。我怎样才能和其他人一起爬下来？实现自动翻页一般有两种方式：
在页面中找到下一页的地址；根据 URL 的变化规律，自己构建所有的页面地址。
一般情况下我们使用第一种方式，第二种方式适用于页面的下一页地址是JS加载的情况。今天我们只讲第一种方法。先用Chrome浏览器的开发者工具找到下一页的地址
然后在解析页面的时候，得到下一页的地址，把地址交给调度器（Scheduler）
from scrapy import Request
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36',
}
def start_requests(self):
url = 'https://movie.douban.com/top250'
yield Request(url, headers=self.headers)
def parse(self, response):
item = DoubanMovieItem()
movies = response.xpath('//ol[@class="grid_view"]/li')
for movie in movies:
item['ranking'] = movie.xpath(
'.//div[@class="pic"]/em/text()').extract()[0]
item['movie_name'] = movie.xpath(
'.//div[@class="hd"]/a/span[1]/text()').extract()[0]
item['score'] = movie.xpath(
'.//div[@class="star"]/span[@class="rating_num"]/text()'
).extract()[0]
item['score_num'] = movie.xpath(
'.//div[@class="star"]/span/text()').re(ur'(\d+)人评价')[0]
yield item
next_url = response.xpath('//span[@class="next"]/a/@href').extract()
if next_url:
next_url = 'https://movie.douban.com/top250' + next_url[0]
yield Request(next_url, headers=self.headers)
最后再次运行爬虫，打开douban.csv。有没有发现已经获取了所有的电影信息，其中250个不超过1个，不小于250个？
最后，使用 WPS 的过滤功能，您可以过滤任何符合您要求的视频。（ps：外国和尚不总是会念经，记得用WPS打开这个CVS文件，用EXCEL打开会因为中文导致显示异常。）
结尾
自从写了这篇 Scrapy 爬虫框架教程后，我越来越觉得把学到的东西导出并没有想象中的那么简单。很多时候，在写了几个小时的教程之后，我发现我仍然无法完美地表达我想要表达的东西。如果有什么不对的地方，请纠正我。有一系列的听证会，并且有艺术行业的专业。我们都互相学习：）
源码地址：Wooden-Robot/scrapy-tutorial
scrapy分页抓取网页( Scrapy二.准备环境三.使用框架1.创建项目使用命令)
网站优化 • 优采云 发表了文章 • 0 个评论 • 46 次浏览 • 2022-02-05 07:22
scrapy分页抓取网页(
Scrapy二.准备环境三.使用框架1.创建项目使用命令)
Python爬虫学习的scrapy框架（一）爬取豆瓣书单
文章目录
Python爬虫学习的scrapy框架（一）爬取豆瓣书单
资源链接
一.什么是 Scrapy
二.准备环境
三.一般流程
四.使用框架
1.创建项目
2.各部分介绍
3.创建爬虫
4.设置数据存储模板
5.分析网页，编写爬虫
6.数据处理
7.设置部分
8.执行爬虫
一.什么是 Scrapy
Scrapy 是一个应用程序框架，用于抓取 网站 数据并提取结构化数据。它可以用于一系列程序，包括数据挖掘、信息处理或存储历史数据。自己写一个Python爬虫也不是不行，但是有框架可以用，何乐而不为呢？相信Scrapy可以事半功倍。与 request 相比，scrapy 侧重于爬虫框架，而不是页面下载。
二.准备环境
scrapy爬虫pypiwin32、lxml、twisted、scrapy、Microsoft Visual C++ 14.0或以上编译环境所需的库
数据库连接模块，pymysql，我用pip安装了上面的库，这里放了清华大学的镜像源 -i /simple
三.一般流程
首先，引擎从调度程序中获取一个链接（URL）用于后续爬取
1.引擎将URL封装成请求（Request）传给下载器，下载器下载资源并封装成响应包（Response）
2.然后，爬虫解析Response。
3.如果实体（Item）被解析，就会交给实体管道做进一步处理。
4.如果解析了一个链接（URL），则将该URL交给Scheduler进行爬取。
四.使用框架创建项目1.
使用命令scrapy startproject projectname
PS D:\pythonpractice> scrapy startproject douban
New Scrapy project 'douban', using template directory 'D:\python38install\Lib\site-packages\scrapy\templates\project', created in:
D:\pythonpractice\douban
You can start your first spider with:
cd douban
scrapy genspider example example.com
我在用vscode，用ctrl和·键唤起终端，输入命令，我要去爬豆瓣的一些页面，所以我把它命名为豆瓣，可以看到你打开的文件夹下出现了一个新文件夹，这是我命名的那个
然后使用cd douban命令进入项目所在文件夹
PS D:\pythonpractice> cd douban
PS D:\pythonpractice\douban>
2.各部分介绍
在项目文件夹中，可以看到还有一个与项目同名的文件夹，里面收录了一些文件，
1.items.py 负责建立数据模型，为结构化数据设置数据存储模板，如：Django的Model
2.middlewares.py 是你自己定义的中间件
3.pipelines.py 负责处理spider返回的数据，比如数据持久化
4.settings.py 负责整个爬虫的配置
5.spiders目录负责存放从scrapy继承而来的爬虫类
6.scrapy.cfg 是scrapy的基本配置
3.创建爬虫
使用 scrapy genspider [options] 创建自己的爬虫，
我进入scrapy genspider book，即创建一个叫book的爬虫，domain部分就是爬虫的范围，爬取的网页不能超过这个域名。
4.设置数据存储模板
修改item.py如下
import scrapy
class DoubanItem(scrapy.Item):
# define the fields for your item here like:
# name = scrapy.Field()
title = scrapy.Field()
img_src = scrapy.Field()
score = scrapy.Field()
publish_house = scrapy.Field()
publish_detail = scrapy.Field()
slogan = scrapy.Field()
detail_addr = scrapy.Field()
comment_people = scrapy.Field()
5.分析网页，编写爬虫
打开网址链接：豆瓣阅读Top 250(/top250)
F12 打开网页的源代码，
可以看出结构很清晰，我需要的是这本书的资料，写book.py如下，
class BookSpider(scrapy.Spider):
name = 'book'
allowed_domains = ['douban.com']
start_urls = ['https://book.douban.com/top250?start=0']
url_sets = set()
def parse(self, response):
if response.url.startswith('https://book.douban.com'):
seclectors = response.xpath('//div[@class="indent"]/table')
for seclector in seclectors:
item = DoubanItem()
item['title'] = seclector.xpath("./tr/td[2]/div/a/@title").extract()[0]
item['img_src'] = seclector.xpath("./tr/td[1]/a/img/@src").extract()[0]
item['publish_detail'] = seclector.xpath("./tr/td[2]/p[@class='pl']/text()").extract()[0]
item['score'] = seclector.xpath("./tr/td[2]/div[@class='star clearfix']/span[@class='rating_nums']/text()").extract()[0]
item['detail_addr'] = seclector.xpath("./tr/td[2]/div[@class='pl2']/a/@href").extract()[0]
#标语爬取
item['slogan'] = seclector.xpath("./tr/td[2]/p[@class='quote']/span/text()").get()
if item['slogan']:
pass
else:
item['slogan'] = '暂无信息'
#评论人数爬取
item['comment_people'] = seclector.xpath("./tr/td[2]/div[@class='star clearfix']/span[@class='pl']/text()").extract()[0]
comment = str(item['comment_people'])
rex = '[0-9]+'
num = re.findall(rex, comment)
if num:
item['comment_people'] = num[0]
else:
item['comment_people'] = '暂无信息'
#出版社爬取
t = str(item['publish_detail'])
s = t.encode() #进行字符串转义
temp = s.decode('utf-8')
pattern="[\u4e00-\u9fa5]*\u51fa\u7248[\u4e00-\u9fa5]*|[\u4e00-\u9fa5]*\u4E66\u5E97[\u4e00-\u9fa5]*" #中文 unicode编码出版 正则表达式
results = re.findall(pattern, temp) #匹配
if results:
item['publish_house'] = results[0]
else:
item['publish_house'] = '暂无信息'
yield item
#分页处理
urls = response.xpath("//div[@class='paginator']/span[@class='next']/a/@href").extract()
for url in urls:
if url.startswith('https://book.douban.com'):
if url in self.url_sets:
pass
else:
self.url_sets.add(url)
yield self.make_requests_from_url(url)
else:
pass
（1）这里start_urls是起始页，后面的页面都是从网页的pager中获取的，但是如果网站使用js进行分页，那就没办法了。
(2）提取网页内容的方法有很多，比如beautifulsoup、lxml，但是scrapy中默认的是selector，相对来说最好用xpath来分析页面，xpath可以自己找了解只是为爬虫分析网页并不是很困难。
（3）对于一本书的封面图，得到它的地址后，可以选择保存到本地，但是由于我个人PC端mysql不喜欢放图片，所以总觉得不是很靠谱，刚爬下它的地址，如果你写了网站，想用这些图片，应该可以直接用地址。
(4）出版商信息爬取部分，由于这个是由作者/出版商/日期/价格组成的，所以我用了一个收录“出版商”、“书店”等关键字的正则表达式字符串。提取出来方便数据持久化后的数据分析。
6.数据处理
编写 pipline.py 如下
from itemadapter import ItemAdapter
import urllib.request
import os
import pymysql
class DoubanPipeline:
def process_item(self, item, spider):
#保存图片
# url = item['img_addr']
# req = urllib.request.Request(url)
# with urllib.request.urlopen(req) as pic:
# data = pic.read()
# file_name = os.path.join(r'D:\bookpic',item['name'] + '.jpg')
# with open(file_name, 'wb') as fp:
# fp.write(data)
#保存到数据库
info = [item['title'], item['score'], item['publish_detail'], item['slogan'], item['publish_house'], item['img_src'], item['detail_addr'], item['comment_people']]
connection = pymysql.connect(host='localhost', user='root', password='', database='', charset='utf8')
try:
with connection.cursor() as cursor:
sql = 'insert into app_book (title, score, publish_detail, slogan, publish_house, img_src, detail_addr, comment_people) values (%s, %s, %s, %s, %s, %s, %s, %s)'
affectedcount = cursor.execute(sql, info)
print('成功修改{0}条数据'.format(affectedcount))
connection.commit()
except pymysql.DatabaseError:
connection.rollback()
finally:
connection.close()
return item
7.设置部分
settings.py 添加如下内容
(1）设置处理返回数据的类和执行优先级
ITEM_PIPELINES = {
'douban.pipelines.DoubanPipeline': 100,
}
(2）添加用户代理
DEFAULT_REQUEST_HEADERS = {
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language': 'en',
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:52.0) G ecko/20100101 Firefox/52.0'
}
8.执行爬虫
输入命令scrapy crawl book，爬虫开始执行 查看全部
Scrapy二.准备环境三.使用框架1.创建项目使用命令)
Python爬虫学习的scrapy框架（一）爬取豆瓣书单
文章目录
Python爬虫学习的scrapy框架（一）爬取豆瓣书单
资源链接
一.什么是 Scrapy
二.准备环境
三.一般流程
四.使用框架
1.创建项目
2.各部分介绍
3.创建爬虫
4.设置数据存储模板
5.分析网页，编写爬虫
6.数据处理
7.设置部分
8.执行爬虫
一.什么是 Scrapy
Scrapy 是一个应用程序框架，用于抓取 网站 数据并提取结构化数据。它可以用于一系列程序，包括数据挖掘、信息处理或存储历史数据。自己写一个Python爬虫也不是不行，但是有框架可以用，何乐而不为呢？相信Scrapy可以事半功倍。与 request 相比，scrapy 侧重于爬虫框架，而不是页面下载。
二.准备环境
scrapy爬虫pypiwin32、lxml、twisted、scrapy、Microsoft Visual C++ 14.0或以上编译环境所需的库
数据库连接模块，pymysql，我用pip安装了上面的库，这里放了清华大学的镜像源 -i /simple
三.一般流程
首先，引擎从调度程序中获取一个链接（URL）用于后续爬取
1.引擎将URL封装成请求（Request）传给下载器，下载器下载资源并封装成响应包（Response）
2.然后，爬虫解析Response。
3.如果实体（Item）被解析，就会交给实体管道做进一步处理。
4.如果解析了一个链接（URL），则将该URL交给Scheduler进行爬取。
四.使用框架创建项目1.
使用命令scrapy startproject projectname
PS D:\pythonpractice> scrapy startproject douban
New Scrapy project 'douban', using template directory 'D:\python38install\Lib\site-packages\scrapy\templates\project', created in:
D:\pythonpractice\douban
You can start your first spider with:
cd douban
scrapy genspider example example.com
我在用vscode，用ctrl和·键唤起终端，输入命令，我要去爬豆瓣的一些页面，所以我把它命名为豆瓣，可以看到你打开的文件夹下出现了一个新文件夹，这是我命名的那个
然后使用cd douban命令进入项目所在文件夹
PS D:\pythonpractice> cd douban
PS D:\pythonpractice\douban>
2.各部分介绍
在项目文件夹中，可以看到还有一个与项目同名的文件夹，里面收录了一些文件，
1.items.py 负责建立数据模型，为结构化数据设置数据存储模板，如：Django的Model
2.middlewares.py 是你自己定义的中间件
3.pipelines.py 负责处理spider返回的数据，比如数据持久化
4.settings.py 负责整个爬虫的配置
5.spiders目录负责存放从scrapy继承而来的爬虫类
6.scrapy.cfg 是scrapy的基本配置
3.创建爬虫
使用 scrapy genspider [options] 创建自己的爬虫，
我进入scrapy genspider book，即创建一个叫book的爬虫，domain部分就是爬虫的范围，爬取的网页不能超过这个域名。
4.设置数据存储模板
修改item.py如下
import scrapy
class DoubanItem(scrapy.Item):
# define the fields for your item here like:
# name = scrapy.Field()
title = scrapy.Field()
img_src = scrapy.Field()
score = scrapy.Field()
publish_house = scrapy.Field()
publish_detail = scrapy.Field()
slogan = scrapy.Field()
detail_addr = scrapy.Field()
comment_people = scrapy.Field()
5.分析网页，编写爬虫
打开网址链接：豆瓣阅读Top 250(/top250)
F12 打开网页的源代码，
可以看出结构很清晰，我需要的是这本书的资料，写book.py如下，
class BookSpider(scrapy.Spider):
name = 'book'
allowed_domains = ['douban.com']
start_urls = ['https://book.douban.com/top250?start=0']
url_sets = set()
def parse(self, response):
if response.url.startswith('https://book.douban.com'):
seclectors = response.xpath('//div[@class="indent"]/table')
for seclector in seclectors:
item = DoubanItem()
item['title'] = seclector.xpath("./tr/td[2]/div/a/@title").extract()[0]
item['img_src'] = seclector.xpath("./tr/td[1]/a/img/@src").extract()[0]
item['publish_detail'] = seclector.xpath("./tr/td[2]/p[@class='pl']/text()").extract()[0]
item['score'] = seclector.xpath("./tr/td[2]/div[@class='star clearfix']/span[@class='rating_nums']/text()").extract()[0]
item['detail_addr'] = seclector.xpath("./tr/td[2]/div[@class='pl2']/a/@href").extract()[0]
#标语爬取
item['slogan'] = seclector.xpath("./tr/td[2]/p[@class='quote']/span/text()").get()
if item['slogan']:
pass
else:
item['slogan'] = '暂无信息'
#评论人数爬取
item['comment_people'] = seclector.xpath("./tr/td[2]/div[@class='star clearfix']/span[@class='pl']/text()").extract()[0]
comment = str(item['comment_people'])
rex = '[0-9]+'
num = re.findall(rex, comment)
if num:
item['comment_people'] = num[0]
else:
item['comment_people'] = '暂无信息'
#出版社爬取
t = str(item['publish_detail'])
s = t.encode() #进行字符串转义
temp = s.decode('utf-8')
pattern="[\u4e00-\u9fa5]*\u51fa\u7248[\u4e00-\u9fa5]*|[\u4e00-\u9fa5]*\u4E66\u5E97[\u4e00-\u9fa5]*" #中文 unicode编码出版 正则表达式
results = re.findall(pattern, temp) #匹配
if results:
item['publish_house'] = results[0]
else:
item['publish_house'] = '暂无信息'
yield item
#分页处理
urls = response.xpath("//div[@class='paginator']/span[@class='next']/a/@href").extract()
for url in urls:
if url.startswith('https://book.douban.com'):
if url in self.url_sets:
pass
else:
self.url_sets.add(url)
yield self.make_requests_from_url(url)
else:
pass
（1）这里start_urls是起始页，后面的页面都是从网页的pager中获取的，但是如果网站使用js进行分页，那就没办法了。
(2）提取网页内容的方法有很多，比如beautifulsoup、lxml，但是scrapy中默认的是selector，相对来说最好用xpath来分析页面，xpath可以自己找了解只是为爬虫分析网页并不是很困难。
（3）对于一本书的封面图，得到它的地址后，可以选择保存到本地，但是由于我个人PC端mysql不喜欢放图片，所以总觉得不是很靠谱，刚爬下它的地址，如果你写了网站，想用这些图片，应该可以直接用地址。
(4）出版商信息爬取部分，由于这个是由作者/出版商/日期/价格组成的，所以我用了一个收录“出版商”、“书店”等关键字的正则表达式字符串。提取出来方便数据持久化后的数据分析。
6.数据处理
编写 pipline.py 如下
from itemadapter import ItemAdapter
import urllib.request
import os
import pymysql
class DoubanPipeline:
def process_item(self, item, spider):
#保存图片
# url = item['img_addr']
# req = urllib.request.Request(url)
# with urllib.request.urlopen(req) as pic:
# data = pic.read()
# file_name = os.path.join(r'D:\bookpic',item['name'] + '.jpg')
# with open(file_name, 'wb') as fp:
# fp.write(data)
#保存到数据库
info = [item['title'], item['score'], item['publish_detail'], item['slogan'], item['publish_house'], item['img_src'], item['detail_addr'], item['comment_people']]
connection = pymysql.connect(host='localhost', user='root', password='', database='', charset='utf8')
try:
with connection.cursor() as cursor:
sql = 'insert into app_book (title, score, publish_detail, slogan, publish_house, img_src, detail_addr, comment_people) values (%s, %s, %s, %s, %s, %s, %s, %s)'
affectedcount = cursor.execute(sql, info)
print('成功修改{0}条数据'.format(affectedcount))
connection.commit()
except pymysql.DatabaseError:
connection.rollback()
finally:
connection.close()
return item
7.设置部分
settings.py 添加如下内容
(1）设置处理返回数据的类和执行优先级
ITEM_PIPELINES = {
'douban.pipelines.DoubanPipeline': 100,
}
(2）添加用户代理
DEFAULT_REQUEST_HEADERS = {
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language': 'en',
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:52.0) G ecko/20100101 Firefox/52.0'
}
8.执行爬虫
输入命令scrapy crawl book，爬虫开始执行 查看全部
scrapy分页抓取网页(
Scrapy二.准备环境三.使用框架1.创建项目使用命令)
Python爬虫学习的scrapy框架（一）爬取豆瓣书单
文章目录
Python爬虫学习的scrapy框架（一）爬取豆瓣书单
资源链接
一.什么是 Scrapy
二.准备环境
三.一般流程
四.使用框架
1.创建项目
2.各部分介绍
3.创建爬虫
4.设置数据存储模板
5.分析网页，编写爬虫
6.数据处理
7.设置部分
8.执行爬虫
一.什么是 Scrapy
Scrapy 是一个应用程序框架，用于抓取 网站 数据并提取结构化数据。它可以用于一系列程序，包括数据挖掘、信息处理或存储历史数据。自己写一个Python爬虫也不是不行，但是有框架可以用，何乐而不为呢？相信Scrapy可以事半功倍。与 request 相比，scrapy 侧重于爬虫框架，而不是页面下载。
二.准备环境
scrapy爬虫pypiwin32、lxml、twisted、scrapy、Microsoft Visual C++ 14.0或以上编译环境所需的库
数据库连接模块，pymysql，我用pip安装了上面的库，这里放了清华大学的镜像源 -i /simple
三.一般流程
首先，引擎从调度程序中获取一个链接（URL）用于后续爬取
1.引擎将URL封装成请求（Request）传给下载器，下载器下载资源并封装成响应包（Response）
2.然后，爬虫解析Response。
3.如果实体（Item）被解析，就会交给实体管道做进一步处理。
4.如果解析了一个链接（URL），则将该URL交给Scheduler进行爬取。
四.使用框架创建项目1.
使用命令scrapy startproject projectname
PS D:\pythonpractice> scrapy startproject douban
New Scrapy project 'douban', using template directory 'D:\python38install\Lib\site-packages\scrapy\templates\project', created in:
D:\pythonpractice\douban
You can start your first spider with:
cd douban
scrapy genspider example example.com
我在用vscode，用ctrl和·键唤起终端，输入命令，我要去爬豆瓣的一些页面，所以我把它命名为豆瓣，可以看到你打开的文件夹下出现了一个新文件夹，这是我命名的那个
然后使用cd douban命令进入项目所在文件夹
PS D:\pythonpractice> cd douban
PS D:\pythonpractice\douban>
2.各部分介绍
在项目文件夹中，可以看到还有一个与项目同名的文件夹，里面收录了一些文件，
1.items.py 负责建立数据模型，为结构化数据设置数据存储模板，如：Django的Model
2.middlewares.py 是你自己定义的中间件
3.pipelines.py 负责处理spider返回的数据，比如数据持久化
4.settings.py 负责整个爬虫的配置
5.spiders目录负责存放从scrapy继承而来的爬虫类
6.scrapy.cfg 是scrapy的基本配置
3.创建爬虫
使用 scrapy genspider [options] 创建自己的爬虫，
我进入scrapy genspider book，即创建一个叫book的爬虫，domain部分就是爬虫的范围，爬取的网页不能超过这个域名。
4.设置数据存储模板
修改item.py如下
import scrapy
class DoubanItem(scrapy.Item):
# define the fields for your item here like:
# name = scrapy.Field()
title = scrapy.Field()
img_src = scrapy.Field()
score = scrapy.Field()
publish_house = scrapy.Field()
publish_detail = scrapy.Field()
slogan = scrapy.Field()
detail_addr = scrapy.Field()
comment_people = scrapy.Field()
5.分析网页，编写爬虫
打开网址链接：豆瓣阅读Top 250(/top250)
F12 打开网页的源代码，
可以看出结构很清晰，我需要的是这本书的资料，写book.py如下，
class BookSpider(scrapy.Spider):
name = 'book'
allowed_domains = ['douban.com']
start_urls = ['https://book.douban.com/top250?start=0']
url_sets = set()
def parse(self, response):
if response.url.startswith('https://book.douban.com'):
seclectors = response.xpath('//div[@class="indent"]/table')
for seclector in seclectors:
item = DoubanItem()
item['title'] = seclector.xpath("./tr/td[2]/div/a/@title").extract()[0]
item['img_src'] = seclector.xpath("./tr/td[1]/a/img/@src").extract()[0]
item['publish_detail'] = seclector.xpath("./tr/td[2]/p[@class='pl']/text()").extract()[0]
item['score'] = seclector.xpath("./tr/td[2]/div[@class='star clearfix']/span[@class='rating_nums']/text()").extract()[0]
item['detail_addr'] = seclector.xpath("./tr/td[2]/div[@class='pl2']/a/@href").extract()[0]
#标语爬取
item['slogan'] = seclector.xpath("./tr/td[2]/p[@class='quote']/span/text()").get()
if item['slogan']:
pass
else:
item['slogan'] = '暂无信息'
#评论人数爬取
item['comment_people'] = seclector.xpath("./tr/td[2]/div[@class='star clearfix']/span[@class='pl']/text()").extract()[0]
comment = str(item['comment_people'])
rex = '[0-9]+'
num = re.findall(rex, comment)
if num:
item['comment_people'] = num[0]
else:
item['comment_people'] = '暂无信息'
#出版社爬取
t = str(item['publish_detail'])
s = t.encode() #进行字符串转义
temp = s.decode('utf-8')
pattern="[\u4e00-\u9fa5]*\u51fa\u7248[\u4e00-\u9fa5]*|[\u4e00-\u9fa5]*\u4E66\u5E97[\u4e00-\u9fa5]*" #中文 unicode编码出版 正则表达式
results = re.findall(pattern, temp) #匹配
if results:
item['publish_house'] = results[0]
else:
item['publish_house'] = '暂无信息'
yield item
#分页处理
urls = response.xpath("//div[@class='paginator']/span[@class='next']/a/@href").extract()
for url in urls:
if url.startswith('https://book.douban.com'):
if url in self.url_sets:
pass
else:
self.url_sets.add(url)
yield self.make_requests_from_url(url)
else:
pass
（1）这里start_urls是起始页，后面的页面都是从网页的pager中获取的，但是如果网站使用js进行分页，那就没办法了。
(2）提取网页内容的方法有很多，比如beautifulsoup、lxml，但是scrapy中默认的是selector，相对来说最好用xpath来分析页面，xpath可以自己找了解只是为爬虫分析网页并不是很困难。
（3）对于一本书的封面图，得到它的地址后，可以选择保存到本地，但是由于我个人PC端mysql不喜欢放图片，所以总觉得不是很靠谱，刚爬下它的地址，如果你写了网站，想用这些图片，应该可以直接用地址。
(4）出版商信息爬取部分，由于这个是由作者/出版商/日期/价格组成的，所以我用了一个收录“出版商”、“书店”等关键字的正则表达式字符串。提取出来方便数据持久化后的数据分析。
6.数据处理
编写 pipline.py 如下
from itemadapter import ItemAdapter
import urllib.request
import os
import pymysql
class DoubanPipeline:
def process_item(self, item, spider):
#保存图片
# url = item['img_addr']
# req = urllib.request.Request(url)
# with urllib.request.urlopen(req) as pic:
# data = pic.read()
# file_name = os.path.join(r'D:\bookpic',item['name'] + '.jpg')
# with open(file_name, 'wb') as fp:
# fp.write(data)
#保存到数据库
info = [item['title'], item['score'], item['publish_detail'], item['slogan'], item['publish_house'], item['img_src'], item['detail_addr'], item['comment_people']]
connection = pymysql.connect(host='localhost', user='root', password='', database='', charset='utf8')
try:
with connection.cursor() as cursor:
sql = 'insert into app_book (title, score, publish_detail, slogan, publish_house, img_src, detail_addr, comment_people) values (%s, %s, %s, %s, %s, %s, %s, %s)'
affectedcount = cursor.execute(sql, info)
print('成功修改{0}条数据'.format(affectedcount))
connection.commit()
except pymysql.DatabaseError:
connection.rollback()
finally:
connection.close()
return item
7.设置部分
settings.py 添加如下内容
(1）设置处理返回数据的类和执行优先级
ITEM_PIPELINES = {
'douban.pipelines.DoubanPipeline': 100,
}
(2）添加用户代理
DEFAULT_REQUEST_HEADERS = {
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language': 'en',
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:52.0) G ecko/20100101 Firefox/52.0'
}
8.执行爬虫
输入命令scrapy crawl book，爬虫开始执行
scrapy分页抓取网页(Python开发的一个web抓取框架（上）|官网)
网站优化 • 优采云 发表了文章 • 0 个评论 • 60 次浏览 • 2022-02-05 07:21
scrapy分页抓取网页(Python开发的一个web抓取框架（上）|官网)
Scrapy，一个用 Python 开发的网页抓取框架。
1 简介
Python 即时网络爬虫最初的目标是把互联网变成一个大数据库。纯开源代码并不是开源的全部。开源的核心是“开放思维”，它聚合了最好的想法、技术和人才。所以会提到很多主导产品，比如Scrapy、ScrapingHub、Import.io等。
本文简要介绍了 Scrapy 的架构。是的，通用提取器 gsExtractor 将被集成到 Scrapy 架构中。
请注意，本文不想重复原文内容，而是为开源Python爬虫的发展方向寻找参考，并以近9年开发网络爬虫的经验为基准，所以这篇文章收录了作者的很多主观评论。如果想阅读Scrapy官方原文，请点击Scrapy官网架构。
2、Scrapy架构图
蜘蛛是为特定目标编写的内容提取器网站，这是通用网络爬虫框架中最可定制的部分。当你使用 Scrapy 创建爬虫项目时，会生成一个爬虫架。只需填写代码，根据其运行方式填写，即可融入到Scrapy的整体数据流中。Python实时网络爬虫开源项目的目标是节省程序员一半以上的时间。关键是提高Spider的定义和测试速度。解决方案见1分钟快速生成网页内容提取器，让整个Scrapy爬虫系统达到快速定制的目的。
3、Scrapy的数据流（Data Flow）
Scrapy 中的数据流由执行引擎控制。以下原文摘自 Scrapy 官网。我根据自己的猜测发表评论，为 GooSeeker 开源爬虫的进一步发展指明方向：
谁来准备 URL？看来是Spider自己准备的，所以可以猜到Scrapy架构部分（不包括Spider）主要是用于事件调度的，与URL的存储无关。它看起来类似于 GooSeeker 会员中心的爬虫指南针。为目标网站准备一批URL，放入罗盘中，为爬虫调度操作做准备。所以，这个开源项目的下一个目标是将 URL 管理放在一个集中的调度库中。
看到这个其实挺难理解的，需要看一些其他的文档才能理解。继第一点之后，引擎从Spider获取URL后，将其封装成Request，交给事件循环，由Scheduler采集，进行调度管理。暂且理解为对Request进行排队。引擎现在查找调度程序接下来要下载的网页的地址。
从调度器申请任务，将申请的任务交给下载器。下载器和引擎之间有一个下载器中间件。这是开发框架的一个重要亮点。开发人员可以在这里进行一些自定义。延期。
下载完成后，会生成一个Response，通过下载器中间件交给引擎。请注意，Response 和前面的 Request 的首字母大写。虽然没看过其他的Scrapy文档，但我猜这是Scrapy框架内部的一个事件对象，也可以推断它是一个异步事件驱动的引擎，就像DS机器的三级事件循环，这对于高性能、低开销的引擎来说是必须的。
一个中间件再次出现，给了开发者足够的发挥空间。
每个蜘蛛按顺序爬取一个网页，当一个完成后，再构造一个Request事件，开始对另一个网页的爬取。
事件分发引擎。
连续运行。
4.接下来的工作
接下来，我们将进一步研究Scrapy的文档，实现Python即时网络爬虫与Scrapy的集成。
5.文档修改历史
2016-06-08：V1.0，首次发布
上一章爬取京东商品列表 下一章Scrapy入门方案回顾 查看全部
Scrapy，一个用 Python 开发的网页抓取框架。
1 简介
Python 即时网络爬虫最初的目标是把互联网变成一个大数据库。纯开源代码并不是开源的全部。开源的核心是“开放思维”，它聚合了最好的想法、技术和人才。所以会提到很多主导产品，比如Scrapy、ScrapingHub、Import.io等。
本文简要介绍了 Scrapy 的架构。是的，通用提取器 gsExtractor 将被集成到 Scrapy 架构中。
请注意，本文不想重复原文内容，而是为开源Python爬虫的发展方向寻找参考，并以近9年开发网络爬虫的经验为基准，所以这篇文章收录了作者的很多主观评论。如果想阅读Scrapy官方原文，请点击Scrapy官网架构。
2、Scrapy架构图
蜘蛛是为特定目标编写的内容提取器网站，这是通用网络爬虫框架中最可定制的部分。当你使用 Scrapy 创建爬虫项目时，会生成一个爬虫架。只需填写代码，根据其运行方式填写，即可融入到Scrapy的整体数据流中。Python实时网络爬虫开源项目的目标是节省程序员一半以上的时间。关键是提高Spider的定义和测试速度。解决方案见1分钟快速生成网页内容提取器，让整个Scrapy爬虫系统达到快速定制的目的。
3、Scrapy的数据流（Data Flow）
Scrapy 中的数据流由执行引擎控制。以下原文摘自 Scrapy 官网。我根据自己的猜测发表评论，为 GooSeeker 开源爬虫的进一步发展指明方向：
谁来准备 URL？看来是Spider自己准备的，所以可以猜到Scrapy架构部分（不包括Spider）主要是用于事件调度的，与URL的存储无关。它看起来类似于 GooSeeker 会员中心的爬虫指南针。为目标网站准备一批URL，放入罗盘中，为爬虫调度操作做准备。所以，这个开源项目的下一个目标是将 URL 管理放在一个集中的调度库中。
看到这个其实挺难理解的，需要看一些其他的文档才能理解。继第一点之后，引擎从Spider获取URL后，将其封装成Request，交给事件循环，由Scheduler采集，进行调度管理。暂且理解为对Request进行排队。引擎现在查找调度程序接下来要下载的网页的地址。
从调度器申请任务，将申请的任务交给下载器。下载器和引擎之间有一个下载器中间件。这是开发框架的一个重要亮点。开发人员可以在这里进行一些自定义。延期。
下载完成后，会生成一个Response，通过下载器中间件交给引擎。请注意，Response 和前面的 Request 的首字母大写。虽然没看过其他的Scrapy文档，但我猜这是Scrapy框架内部的一个事件对象，也可以推断它是一个异步事件驱动的引擎，就像DS机器的三级事件循环，这对于高性能、低开销的引擎来说是必须的。
一个中间件再次出现，给了开发者足够的发挥空间。
每个蜘蛛按顺序爬取一个网页，当一个完成后，再构造一个Request事件，开始对另一个网页的爬取。
事件分发引擎。
连续运行。
4.接下来的工作
接下来，我们将进一步研究Scrapy的文档，实现Python即时网络爬虫与Scrapy的集成。
5.文档修改历史
2016-06-08：V1.0，首次发布
上一章爬取京东商品列表 下一章Scrapy入门方案回顾 查看全部
scrapy分页抓取网页(Python开发的一个web抓取框架（上）|官网)
Scrapy，一个用 Python 开发的网页抓取框架。
1 简介
Python 即时网络爬虫最初的目标是把互联网变成一个大数据库。纯开源代码并不是开源的全部。开源的核心是“开放思维”，它聚合了最好的想法、技术和人才。所以会提到很多主导产品，比如Scrapy、ScrapingHub、Import.io等。
本文简要介绍了 Scrapy 的架构。是的，通用提取器 gsExtractor 将被集成到 Scrapy 架构中。
请注意，本文不想重复原文内容，而是为开源Python爬虫的发展方向寻找参考，并以近9年开发网络爬虫的经验为基准，所以这篇文章收录了作者的很多主观评论。如果想阅读Scrapy官方原文，请点击Scrapy官网架构。
2、Scrapy架构图
蜘蛛是为特定目标编写的内容提取器网站，这是通用网络爬虫框架中最可定制的部分。当你使用 Scrapy 创建爬虫项目时，会生成一个爬虫架。只需填写代码，根据其运行方式填写，即可融入到Scrapy的整体数据流中。Python实时网络爬虫开源项目的目标是节省程序员一半以上的时间。关键是提高Spider的定义和测试速度。解决方案见1分钟快速生成网页内容提取器，让整个Scrapy爬虫系统达到快速定制的目的。
3、Scrapy的数据流（Data Flow）
Scrapy 中的数据流由执行引擎控制。以下原文摘自 Scrapy 官网。我根据自己的猜测发表评论，为 GooSeeker 开源爬虫的进一步发展指明方向：
谁来准备 URL？看来是Spider自己准备的，所以可以猜到Scrapy架构部分（不包括Spider）主要是用于事件调度的，与URL的存储无关。它看起来类似于 GooSeeker 会员中心的爬虫指南针。为目标网站准备一批URL，放入罗盘中，为爬虫调度操作做准备。所以，这个开源项目的下一个目标是将 URL 管理放在一个集中的调度库中。
看到这个其实挺难理解的，需要看一些其他的文档才能理解。继第一点之后，引擎从Spider获取URL后，将其封装成Request，交给事件循环，由Scheduler采集，进行调度管理。暂且理解为对Request进行排队。引擎现在查找调度程序接下来要下载的网页的地址。
从调度器申请任务，将申请的任务交给下载器。下载器和引擎之间有一个下载器中间件。这是开发框架的一个重要亮点。开发人员可以在这里进行一些自定义。延期。
下载完成后，会生成一个Response，通过下载器中间件交给引擎。请注意，Response 和前面的 Request 的首字母大写。虽然没看过其他的Scrapy文档，但我猜这是Scrapy框架内部的一个事件对象，也可以推断它是一个异步事件驱动的引擎，就像DS机器的三级事件循环，这对于高性能、低开销的引擎来说是必须的。
一个中间件再次出现，给了开发者足够的发挥空间。
每个蜘蛛按顺序爬取一个网页，当一个完成后，再构造一个Request事件，开始对另一个网页的爬取。
事件分发引擎。
连续运行。
4.接下来的工作
接下来，我们将进一步研究Scrapy的文档，实现Python即时网络爬虫与Scrapy的集成。
5.文档修改历史
2016-06-08：V1.0，首次发布
上一章爬取京东商品列表 下一章Scrapy入门方案回顾
scrapy分页抓取网页( Scrapy的安装输入密码安装完成/scrapy.py)
网站优化 • 优采云 发表了文章 • 0 个评论 • 47 次浏览 • 2022-02-05 06:10
scrapy分页抓取网页(
Scrapy的安装输入密码安装完成/scrapy.py)
Scrapy入门教程——爬上iTunes应用列表
什么是刮痧？
Scrapy 是一个开源的基于 Twisted 的 Python 爬虫框架。我们只需要自定义几个简单的模块即可爬取网络数据。Scrapy的整体架构
简单解释一下上图：
爬虫处理的原材料是一个或多个url。爬取时，Sheduler 会为Downloader 分配一个url 进行网络请求请求。请求完成后，Downloader 会将获取到的响应传给 Spider。如果返回的数据是我们需要的，则将数据处理成对应的Item，交给ItemPipeline进行存储等处理。如果返回的url还是要处理的url，那么就必须交给Scheduler进行另一个处理过程。
3.Scrapy 的安装
sudo pip_install scrapy 或 sudo easy_intall scrapy
输入密码，安装完成。如果你使用scrapy，如果没有找不到命令，就说明安装成功了。
4.创建一个项目
scrapy startproject project_name
如果看到上面的提示，那么我们的项目就创建成功了。切换到项目目录，我们会看到如下目录结构
应用程序/
整个项目的scrapy.cfg配置信息
所有 python 自定义模块的 appScrapy/ 文件夹
初始化文件
items.py 数据结构保存爬取的数据
pipelines.py 数据流处理文件，对爬取的数据流进行处理
settings.py 设置文件，其中设置了数据库等
spiders/ 存储我们的自定义蜘蛛
初始化文件
…
让我们找到完整的目标，appStore的娱乐图表
我们要爬取的数据是列表中应用的名称及其对应的具体信息的url。
首先我们自定义我们用来保存数据类型的items.py，打开items.py，添加代码如下：
import scrapy
class AppscrapyItem(scrapy.Item):
# define the fields for your item here like:
name = scrapy.Field()
url = scrapy.Field()
简单来说，所有item都继承自scrapy.Item，里面的字段是scrapy.Field()类型，scrapy.Field()可以接收任何数据类型。
现在是时候自定义我们的爬虫了。
在 spiders 文件夹中创建一个 AppScrapy.py，然后打开并添加以下代码
from scrapy.spider import BaseSpider
from appScrapy.items import AppscrapyItem
class AppScrapy(BaseSpider):
name = ‘app_scrapy‘
start_urls = ["https://itunes.apple.com/cn/ge ... ot%3B]
def parse(self, response):
result = []
lis = response.xpath("//div[@class=‘grid3-column‘]/div")
for li in lis:
array = li.xpath("./ul/li")
for node in array:
item = AppscrapyItem()
item["name"] = node.xpath("./a/text()").extract()
item["url"] = node.xpath("./a/@href").extract()
result.append(item)
return result
所有的爬虫类都需要继承自BaseSpider，并且必须定义一个名字，因为我们需要用这个名字来启动爬虫。一个url数组，爬虫有必要知道它应该去哪里。最后，必须实现 parse 方法。在这里，爬回来的数据真的是经过过滤得到我们想要的。
当我们启动爬虫（scrapy crawl app_scrapy）时，scrapy会从start_urls中取第一个url，用这个url发起请求，并使用parse作为请求的回调函数，回调函数中的response就是request的response请求后收到。
对于内容的选择，我们使用 xpath 方法。xpath 方法需要输入路径并返回选择器数组。
对于路径，我们可以使用Chrome的开发者工具来获取，如上图。当我们要获取内容的时候，只要选择Element选项卡下的内容，然后右键选择copy xPath
lis = response.xpath("//div[@class=‘grid3-column‘]/div")
首先，我们使用xpath获取class = 'grid3-column'的div中的所有div，返回值是一个数组。从上图中我们可以看出，数组中应该有 3 个选择器代表 div。
每个 div 中的内容如上图所示。我们取出每个 div 并解析其内容。
for li in lis:
array = li.xpath("./ul/li")
for node in array:
item = AppscrapyItem()
item["name"] = node.xpath("./a/text()").extract()
item["url"] = node.xpath("./a/@href").extract()
result.append(item)
先用for循环取出每个div，然后获取当前div下所有ul下的所有li，如上图所示，我们会得到一个代表li的选择器数组。再来看看li的结构
中间的文本是通过text()获取的，所以当前li的文本路径是“./a/text()”“.” 表示当前选择器的开始。如果返回，xpath 返回一个选择器。如果我们想得到它的真实值，我们需要调用extract()，它会返回一个真实文字值的数组。
要获取字段的属性值，需要使用@，比如上面的@href，然后将这些值赋给我们写的item。
当然，数据应该保存，并且会继续。下次如何保存到数据库中。
时间：03-08
Scrapy入门教程--爬取iTunes应用列表相关文章Scrapy入门教程
在这个介绍性教程中，我们假设您已经安装了 Scrapy。如果没有，请参阅安装指南。我们将使用 Open Directory Project (dmoz) 作为抓取示例。本介绍性教程将引导您完成以下任务： 创建一个新的 Scrapy 项目以定义提取的项目 编写一个蜘蛛来爬取站点并提取项目 编写一个项目管道来存储提取的项目 Scrapy 是用 Python 编写的。如果您是 Python 新手，您可能希望从了解 Python 开始，以便最好地使用 Scrapy。如果你熟悉其他编程语言，想快速学习
Python的scrapy入门教程
看了这篇文章的同学，我假设大家都学过python（Pyson），那么下面的知识就是python的一个扩展（framework）。在这个介绍性教程中，我们假设您已经安装了 Scrapy。如果您还没有安装它，请参阅安装指南。我们将使用 Open Directory Project (dmoz) 作为抓取示例。本介绍性教程将指导您完成以下任务： 创建一个新的 Scrapy 项目，定义提取的项目 编写一个蜘蛛来抓取站点并提取项目 编写一个项目管道来存储提取的项目 Scrapy 是用 Python 编写的。如果你是皮思
开始使用 Scrapy
Scrapy 是一个用 Python 编写的应用程序框架，用于爬取 网站 数据并提取结构化数据。Scrapy 常用于数据挖掘、信息处理或存储历史数据等一系列程序中。通常我们通过 Scrapy 框架实现爬虫来抓取指定 网站 的内容或图片是非常简单的。Scrapy架构图（绿线为数据流） Scrapy Engine（引擎）：负责Spider.ItemPipeline.Downloader.Scheduler中间的通信、信号、数据传输等调度器：负责接收引擎
在 Scrapy 入门教程中写入数据库
那么前面的文章会讲到如何将抓取到的数据写入数据库。1. 爬虫脚本还是以爬虫百科为例，脚本编写保存在Hello/spiders目录下的spider_qiushibaike中。py 文件 # -*- 编码：utf-8 -*- import scrapy from Hello.items import HelloItem class Spider_qiush
Angular2 入门教程-2 实现 TodoList 应用
最近在学习中遇到一些问题（机械工业出版社），没看懂书上说的什么。我在网上找了一些，资源很多，也有很多以前的经验。原文： 原文地址：
Scrapy安装、爬虫入门教程、爬虫示例（豆瓣电影爬虫）
窗口上Scrapy的安装教程见以下链接： Scrapy安装教程 以上安装教程已经实践过，可行。本来打算在ubuntu上安装scrapy，但是ubuntu磁盘空间太小，还没有扩充磁盘空间，暂时不想再安装太多软件了。Scrapy的入门教程见以下链接： 上面的入门教程很基础。先跟随作者，动起来。不要只阅读上面的介绍性教程。这是一个简短的总结。我们来看看Scrapy爬虫流程：1.在Item中定义你要爬取的数据：movie_name就像字典中的“key”，爬取的数量
Scrapy 框架入门
Scrapy 入门教程 在本教程中，我已经安装了 Scrapy。本教程将带您完成以下任务： 创建一个 Scrapy 项目以定义提取的项目 编写一个爬取 网站 的蜘蛛并提取项目 编写一个项目管道来存储提取的项目（即数据） 创建一个项目 之前开始抓取，您必须创建一个新的 Scrapy 项目。转到您打算存储代码的目录并运行以下命令：scrapy startproject tutorial tutorial/ scrapy.cfg tutorial/ __init__
[scrapy] 开始学习Scrapy
Scrapy 简介 Scrapy 是一个用于爬取网站 数据并提取结构化数据的应用程序框架。它可用于数据挖掘、信息处理或历史数据存储等一系列程序中。所谓网络爬虫，就是在互联网上到处或有针对性地爬取数据的程序。当然，这种说法不够专业。更专业的描述是爬取特定网站网页的HTML数据。爬取网页的一般方法是定义一个条目。页面，然后一般一个页面会有其他页面的url，所以这些url是从当前页面获取的，加入爬虫的抓取队列，然后进入新页面，然后递归执行上述操作。实际上，它与深度有关，与遍历或广度遍历相同。屏幕截图
2015最新Android基础入门教程目录（汉化版）
2015最新Android基础入门教程目录（最终版） 标签（空格分隔）：Android基础入门教程 前言：关于今天终于结束了，全套教程一共写了148节，附目录，关于教程的由来，作者的情况和自学经验，资源分享以及一些问题可以戳：成品散花~以下是本系列教程的完整目录：第一章：环境搭建与开发（ 10月1日完成0)Android Basic入门教程--1.1背景及系统架构 查看全部
Scrapy的安装输入密码安装完成/scrapy.py)
Scrapy入门教程——爬上iTunes应用列表
什么是刮痧？
Scrapy 是一个开源的基于 Twisted 的 Python 爬虫框架。我们只需要自定义几个简单的模块即可爬取网络数据。Scrapy的整体架构
简单解释一下上图：
爬虫处理的原材料是一个或多个url。爬取时，Sheduler 会为Downloader 分配一个url 进行网络请求请求。请求完成后，Downloader 会将获取到的响应传给 Spider。如果返回的数据是我们需要的，则将数据处理成对应的Item，交给ItemPipeline进行存储等处理。如果返回的url还是要处理的url，那么就必须交给Scheduler进行另一个处理过程。
3.Scrapy 的安装
sudo pip_install scrapy 或 sudo easy_intall scrapy
输入密码，安装完成。如果你使用scrapy，如果没有找不到命令，就说明安装成功了。
4.创建一个项目
scrapy startproject project_name
如果看到上面的提示，那么我们的项目就创建成功了。切换到项目目录，我们会看到如下目录结构
应用程序/
整个项目的scrapy.cfg配置信息
所有 python 自定义模块的 appScrapy/ 文件夹
初始化文件
items.py 数据结构保存爬取的数据
pipelines.py 数据流处理文件，对爬取的数据流进行处理
settings.py 设置文件，其中设置了数据库等
spiders/ 存储我们的自定义蜘蛛
初始化文件
…
让我们找到完整的目标，appStore的娱乐图表
我们要爬取的数据是列表中应用的名称及其对应的具体信息的url。
首先我们自定义我们用来保存数据类型的items.py，打开items.py，添加代码如下：
import scrapy
class AppscrapyItem(scrapy.Item):
# define the fields for your item here like:
name = scrapy.Field()
url = scrapy.Field()
简单来说，所有item都继承自scrapy.Item，里面的字段是scrapy.Field()类型，scrapy.Field()可以接收任何数据类型。
现在是时候自定义我们的爬虫了。
在 spiders 文件夹中创建一个 AppScrapy.py，然后打开并添加以下代码
from scrapy.spider import BaseSpider
from appScrapy.items import AppscrapyItem
class AppScrapy(BaseSpider):
name = ‘app_scrapy‘
start_urls = ["https://itunes.apple.com/cn/ge ... ot%3B]
def parse(self, response):
result = []
lis = response.xpath("//div[@class=‘grid3-column‘]/div")
for li in lis:
array = li.xpath("./ul/li")
for node in array:
item = AppscrapyItem()
item["name"] = node.xpath("./a/text()").extract()
item["url"] = node.xpath("./a/@href").extract()
result.append(item)
return result
所有的爬虫类都需要继承自BaseSpider，并且必须定义一个名字，因为我们需要用这个名字来启动爬虫。一个url数组，爬虫有必要知道它应该去哪里。最后，必须实现 parse 方法。在这里，爬回来的数据真的是经过过滤得到我们想要的。
当我们启动爬虫（scrapy crawl app_scrapy）时，scrapy会从start_urls中取第一个url，用这个url发起请求，并使用parse作为请求的回调函数，回调函数中的response就是request的response请求后收到。
对于内容的选择，我们使用 xpath 方法。xpath 方法需要输入路径并返回选择器数组。
对于路径，我们可以使用Chrome的开发者工具来获取，如上图。当我们要获取内容的时候，只要选择Element选项卡下的内容，然后右键选择copy xPath
lis = response.xpath("//div[@class=‘grid3-column‘]/div")
首先，我们使用xpath获取class = 'grid3-column'的div中的所有div，返回值是一个数组。从上图中我们可以看出，数组中应该有 3 个选择器代表 div。
每个 div 中的内容如上图所示。我们取出每个 div 并解析其内容。
for li in lis:
array = li.xpath("./ul/li")
for node in array:
item = AppscrapyItem()
item["name"] = node.xpath("./a/text()").extract()
item["url"] = node.xpath("./a/@href").extract()
result.append(item)
先用for循环取出每个div，然后获取当前div下所有ul下的所有li，如上图所示，我们会得到一个代表li的选择器数组。再来看看li的结构
中间的文本是通过text()获取的，所以当前li的文本路径是“./a/text()”“.” 表示当前选择器的开始。如果返回，xpath 返回一个选择器。如果我们想得到它的真实值，我们需要调用extract()，它会返回一个真实文字值的数组。
要获取字段的属性值，需要使用@，比如上面的@href，然后将这些值赋给我们写的item。
当然，数据应该保存，并且会继续。下次如何保存到数据库中。
时间：03-08
Scrapy入门教程--爬取iTunes应用列表相关文章Scrapy入门教程
在这个介绍性教程中，我们假设您已经安装了 Scrapy。如果没有，请参阅安装指南。我们将使用 Open Directory Project (dmoz) 作为抓取示例。本介绍性教程将引导您完成以下任务： 创建一个新的 Scrapy 项目以定义提取的项目 编写一个蜘蛛来爬取站点并提取项目 编写一个项目管道来存储提取的项目 Scrapy 是用 Python 编写的。如果您是 Python 新手，您可能希望从了解 Python 开始，以便最好地使用 Scrapy。如果你熟悉其他编程语言，想快速学习
Python的scrapy入门教程
看了这篇文章的同学，我假设大家都学过python（Pyson），那么下面的知识就是python的一个扩展（framework）。在这个介绍性教程中，我们假设您已经安装了 Scrapy。如果您还没有安装它，请参阅安装指南。我们将使用 Open Directory Project (dmoz) 作为抓取示例。本介绍性教程将指导您完成以下任务： 创建一个新的 Scrapy 项目，定义提取的项目 编写一个蜘蛛来抓取站点并提取项目 编写一个项目管道来存储提取的项目 Scrapy 是用 Python 编写的。如果你是皮思
开始使用 Scrapy
Scrapy 是一个用 Python 编写的应用程序框架，用于爬取 网站 数据并提取结构化数据。Scrapy 常用于数据挖掘、信息处理或存储历史数据等一系列程序中。通常我们通过 Scrapy 框架实现爬虫来抓取指定 网站 的内容或图片是非常简单的。Scrapy架构图（绿线为数据流） Scrapy Engine（引擎）：负责Spider.ItemPipeline.Downloader.Scheduler中间的通信、信号、数据传输等调度器：负责接收引擎
在 Scrapy 入门教程中写入数据库
那么前面的文章会讲到如何将抓取到的数据写入数据库。1. 爬虫脚本还是以爬虫百科为例，脚本编写保存在Hello/spiders目录下的spider_qiushibaike中。py 文件 # -*- 编码：utf-8 -*- import scrapy from Hello.items import HelloItem class Spider_qiush
Angular2 入门教程-2 实现 TodoList 应用
最近在学习中遇到一些问题（机械工业出版社），没看懂书上说的什么。我在网上找了一些，资源很多，也有很多以前的经验。原文： 原文地址：
Scrapy安装、爬虫入门教程、爬虫示例（豆瓣电影爬虫）
窗口上Scrapy的安装教程见以下链接： Scrapy安装教程 以上安装教程已经实践过，可行。本来打算在ubuntu上安装scrapy，但是ubuntu磁盘空间太小，还没有扩充磁盘空间，暂时不想再安装太多软件了。Scrapy的入门教程见以下链接： 上面的入门教程很基础。先跟随作者，动起来。不要只阅读上面的介绍性教程。这是一个简短的总结。我们来看看Scrapy爬虫流程：1.在Item中定义你要爬取的数据：movie_name就像字典中的“key”，爬取的数量
Scrapy 框架入门
Scrapy 入门教程 在本教程中，我已经安装了 Scrapy。本教程将带您完成以下任务： 创建一个 Scrapy 项目以定义提取的项目 编写一个爬取 网站 的蜘蛛并提取项目 编写一个项目管道来存储提取的项目（即数据） 创建一个项目 之前开始抓取，您必须创建一个新的 Scrapy 项目。转到您打算存储代码的目录并运行以下命令：scrapy startproject tutorial tutorial/ scrapy.cfg tutorial/ __init__
[scrapy] 开始学习Scrapy
Scrapy 简介 Scrapy 是一个用于爬取网站 数据并提取结构化数据的应用程序框架。它可用于数据挖掘、信息处理或历史数据存储等一系列程序中。所谓网络爬虫，就是在互联网上到处或有针对性地爬取数据的程序。当然，这种说法不够专业。更专业的描述是爬取特定网站网页的HTML数据。爬取网页的一般方法是定义一个条目。页面，然后一般一个页面会有其他页面的url，所以这些url是从当前页面获取的，加入爬虫的抓取队列，然后进入新页面，然后递归执行上述操作。实际上，它与深度有关，与遍历或广度遍历相同。屏幕截图
2015最新Android基础入门教程目录（汉化版）
2015最新Android基础入门教程目录（最终版） 标签（空格分隔）：Android基础入门教程 前言：关于今天终于结束了，全套教程一共写了148节，附目录，关于教程的由来，作者的情况和自学经验，资源分享以及一些问题可以戳：成品散花~以下是本系列教程的完整目录：第一章：环境搭建与开发（ 10月1日完成0)Android Basic入门教程--1.1背景及系统架构 查看全部
scrapy分页抓取网页(
Scrapy的安装输入密码安装完成/scrapy.py)
Scrapy入门教程——爬上iTunes应用列表
什么是刮痧？
Scrapy 是一个开源的基于 Twisted 的 Python 爬虫框架。我们只需要自定义几个简单的模块即可爬取网络数据。Scrapy的整体架构
简单解释一下上图：
爬虫处理的原材料是一个或多个url。爬取时，Sheduler 会为Downloader 分配一个url 进行网络请求请求。请求完成后，Downloader 会将获取到的响应传给 Spider。如果返回的数据是我们需要的，则将数据处理成对应的Item，交给ItemPipeline进行存储等处理。如果返回的url还是要处理的url，那么就必须交给Scheduler进行另一个处理过程。
3.Scrapy 的安装
sudo pip_install scrapy 或 sudo easy_intall scrapy
输入密码，安装完成。如果你使用scrapy，如果没有找不到命令，就说明安装成功了。
4.创建一个项目
scrapy startproject project_name
如果看到上面的提示，那么我们的项目就创建成功了。切换到项目目录，我们会看到如下目录结构
应用程序/
整个项目的scrapy.cfg配置信息
所有 python 自定义模块的 appScrapy/ 文件夹
初始化文件
items.py 数据结构保存爬取的数据
pipelines.py 数据流处理文件，对爬取的数据流进行处理
settings.py 设置文件，其中设置了数据库等
spiders/ 存储我们的自定义蜘蛛
初始化文件
…
让我们找到完整的目标，appStore的娱乐图表
我们要爬取的数据是列表中应用的名称及其对应的具体信息的url。
首先我们自定义我们用来保存数据类型的items.py，打开items.py，添加代码如下：
import scrapy
class AppscrapyItem(scrapy.Item):
# define the fields for your item here like:
name = scrapy.Field()
url = scrapy.Field()
简单来说，所有item都继承自scrapy.Item，里面的字段是scrapy.Field()类型，scrapy.Field()可以接收任何数据类型。
现在是时候自定义我们的爬虫了。
在 spiders 文件夹中创建一个 AppScrapy.py，然后打开并添加以下代码
from scrapy.spider import BaseSpider
from appScrapy.items import AppscrapyItem
class AppScrapy(BaseSpider):
name = ‘app_scrapy‘
start_urls = ["https://itunes.apple.com/cn/ge ... ot%3B]
def parse(self, response):
result = []
lis = response.xpath("//div[@class=‘grid3-column‘]/div")
for li in lis:
array = li.xpath("./ul/li")
for node in array:
item = AppscrapyItem()
item["name"] = node.xpath("./a/text()").extract()
item["url"] = node.xpath("./a/@href").extract()
result.append(item)
return result
所有的爬虫类都需要继承自BaseSpider，并且必须定义一个名字，因为我们需要用这个名字来启动爬虫。一个url数组，爬虫有必要知道它应该去哪里。最后，必须实现 parse 方法。在这里，爬回来的数据真的是经过过滤得到我们想要的。
当我们启动爬虫（scrapy crawl app_scrapy）时，scrapy会从start_urls中取第一个url，用这个url发起请求，并使用parse作为请求的回调函数，回调函数中的response就是request的response请求后收到。
对于内容的选择，我们使用 xpath 方法。xpath 方法需要输入路径并返回选择器数组。
对于路径，我们可以使用Chrome的开发者工具来获取，如上图。当我们要获取内容的时候，只要选择Element选项卡下的内容，然后右键选择copy xPath
lis = response.xpath("//div[@class=‘grid3-column‘]/div")
首先，我们使用xpath获取class = 'grid3-column'的div中的所有div，返回值是一个数组。从上图中我们可以看出，数组中应该有 3 个选择器代表 div。
每个 div 中的内容如上图所示。我们取出每个 div 并解析其内容。
for li in lis:
array = li.xpath("./ul/li")
for node in array:
item = AppscrapyItem()
item["name"] = node.xpath("./a/text()").extract()
item["url"] = node.xpath("./a/@href").extract()
result.append(item)
先用for循环取出每个div，然后获取当前div下所有ul下的所有li，如上图所示，我们会得到一个代表li的选择器数组。再来看看li的结构
中间的文本是通过text()获取的，所以当前li的文本路径是“./a/text()”“.” 表示当前选择器的开始。如果返回，xpath 返回一个选择器。如果我们想得到它的真实值，我们需要调用extract()，它会返回一个真实文字值的数组。
要获取字段的属性值，需要使用@，比如上面的@href，然后将这些值赋给我们写的item。
当然，数据应该保存，并且会继续。下次如何保存到数据库中。
时间：03-08
Scrapy入门教程--爬取iTunes应用列表相关文章Scrapy入门教程
在这个介绍性教程中，我们假设您已经安装了 Scrapy。如果没有，请参阅安装指南。我们将使用 Open Directory Project (dmoz) 作为抓取示例。本介绍性教程将引导您完成以下任务： 创建一个新的 Scrapy 项目以定义提取的项目 编写一个蜘蛛来爬取站点并提取项目 编写一个项目管道来存储提取的项目 Scrapy 是用 Python 编写的。如果您是 Python 新手，您可能希望从了解 Python 开始，以便最好地使用 Scrapy。如果你熟悉其他编程语言，想快速学习
Python的scrapy入门教程
看了这篇文章的同学，我假设大家都学过python（Pyson），那么下面的知识就是python的一个扩展（framework）。在这个介绍性教程中，我们假设您已经安装了 Scrapy。如果您还没有安装它，请参阅安装指南。我们将使用 Open Directory Project (dmoz) 作为抓取示例。本介绍性教程将指导您完成以下任务： 创建一个新的 Scrapy 项目，定义提取的项目 编写一个蜘蛛来抓取站点并提取项目 编写一个项目管道来存储提取的项目 Scrapy 是用 Python 编写的。如果你是皮思
开始使用 Scrapy
Scrapy 是一个用 Python 编写的应用程序框架，用于爬取 网站 数据并提取结构化数据。Scrapy 常用于数据挖掘、信息处理或存储历史数据等一系列程序中。通常我们通过 Scrapy 框架实现爬虫来抓取指定 网站 的内容或图片是非常简单的。Scrapy架构图（绿线为数据流） Scrapy Engine（引擎）：负责Spider.ItemPipeline.Downloader.Scheduler中间的通信、信号、数据传输等调度器：负责接收引擎
在 Scrapy 入门教程中写入数据库
那么前面的文章会讲到如何将抓取到的数据写入数据库。1. 爬虫脚本还是以爬虫百科为例，脚本编写保存在Hello/spiders目录下的spider_qiushibaike中。py 文件 # -*- 编码：utf-8 -*- import scrapy from Hello.items import HelloItem class Spider_qiush
Angular2 入门教程-2 实现 TodoList 应用
最近在学习中遇到一些问题（机械工业出版社），没看懂书上说的什么。我在网上找了一些，资源很多，也有很多以前的经验。原文： 原文地址：
Scrapy安装、爬虫入门教程、爬虫示例（豆瓣电影爬虫）
窗口上Scrapy的安装教程见以下链接： Scrapy安装教程 以上安装教程已经实践过，可行。本来打算在ubuntu上安装scrapy，但是ubuntu磁盘空间太小，还没有扩充磁盘空间，暂时不想再安装太多软件了。Scrapy的入门教程见以下链接： 上面的入门教程很基础。先跟随作者，动起来。不要只阅读上面的介绍性教程。这是一个简短的总结。我们来看看Scrapy爬虫流程：1.在Item中定义你要爬取的数据：movie_name就像字典中的“key”，爬取的数量
Scrapy 框架入门
Scrapy 入门教程 在本教程中，我已经安装了 Scrapy。本教程将带您完成以下任务： 创建一个 Scrapy 项目以定义提取的项目 编写一个爬取 网站 的蜘蛛并提取项目 编写一个项目管道来存储提取的项目（即数据） 创建一个项目 之前开始抓取，您必须创建一个新的 Scrapy 项目。转到您打算存储代码的目录并运行以下命令：scrapy startproject tutorial tutorial/ scrapy.cfg tutorial/ __init__
[scrapy] 开始学习Scrapy
Scrapy 简介 Scrapy 是一个用于爬取网站 数据并提取结构化数据的应用程序框架。它可用于数据挖掘、信息处理或历史数据存储等一系列程序中。所谓网络爬虫，就是在互联网上到处或有针对性地爬取数据的程序。当然，这种说法不够专业。更专业的描述是爬取特定网站网页的HTML数据。爬取网页的一般方法是定义一个条目。页面，然后一般一个页面会有其他页面的url，所以这些url是从当前页面获取的，加入爬虫的抓取队列，然后进入新页面，然后递归执行上述操作。实际上，它与深度有关，与遍历或广度遍历相同。屏幕截图
2015最新Android基础入门教程目录（汉化版）
2015最新Android基础入门教程目录（最终版） 标签（空格分隔）：Android基础入门教程 前言：关于今天终于结束了，全套教程一共写了148节，附目录，关于教程的由来，作者的情况和自学经验，资源分享以及一些问题可以戳：成品散花~以下是本系列教程的完整目录：第一章：环境搭建与开发（ 10月1日完成0)Android Basic入门教程--1.1背景及系统架构
scrapy分页抓取网页(国内docker仓库镜像对比安装运行Splash.jsJS渲染解析 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 48 次浏览 • 2022-02-03 18:01
scrapy分页抓取网页(国内docker仓库镜像对比安装运行Splash.jsJS渲染解析
)
随着越来越多的网站开始在客户端浏览器中使用JS动态渲染网站，很多我们需要的数据无法从原创html中获取，加上Scrapy不提供JS渲染和解析的功能。通常，我们一般使用两种方法来爬取这种类型的网站数据：
通过分析网站，找到数据对应的接口，模拟接口获取我们需要的数据（见Scrapy抓取Ajax动态页面），但是一旦网站的接口被隐藏深入，或者接口的加密太复杂，这种方法可能行不通。在JS内核的帮助下，将得到的收录JS脚本的页面交给JS内核进行渲染，最后将渲染后生成的html返回给Scrapy进行分析，这是比较常见的WebKit和Scrapy-Splash
本文文章的目的是介绍如何使用Scrapy-Splash用Scrapy爬取动态页面。
准备
Docker安装，具体安装步骤请参考Docker官网
为什么要安装 Docker？
由于Scrapy-Splash使用Splash HTTP API，需要提供Splash实例，并且Docker镜像中已经存在Splash实例，可以方便的使用。
Docker镜像源变更，参考国内docker仓库镜像对比
安装并运行 Splash
docker pull scrapinghub/splash #从docker镜像中拉取splash实例
docker run -p 8050:8050 scrapinghub/splash #启动splash实例
Scrapy 配置
在 Scrapy 项目的 setting.py 中添加以下内容：
SPLASH_URL = 'http://localhost:8050'
DOWNLOADER_MIDDLEWARES = {
'scrapy_splash.SplashCookiesMiddleware': 723,
'scrapy_splash.SplashMiddleware': 725,
'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 810,
}
SPIDER_MIDDLEWARES = {
'scrapy_splash.SplashDeduplicateArgsMiddleware': 100,
}
DUPEFILTER_CLASS = 'scrapy_splash.SplashAwareDupeFilter'
HTTPCACHE_STORAGE = 'scrapy_splash.SplashAwareFSCacheStorage'
实际代码分析
我们以腾讯证券页面为例。腾讯证券新闻列表是js动态渲染的
我们直接打开这个链接，然后打开开发者工具，找到新闻列表：
当我们查看网络第一个请求的Response时，发现返回的html中的列表页是空的
实际数据隐藏在JS中，加载完成后通过JS操作完成DOM插入
因为这里实际数据是塞进了一个JS变量中，并不是通过Ajax调用接口获取的，所以为了避免手动拦截JS变量，我们将页面交给Scrapy-Splash进行渲染
import scrapy
from FinancialInfoSpider.items import ArticleItem
from scrapy_splash import SplashRequest
from w3lib.html import remove_tags
import re
from bs4 import BeautifulSoup
class TencentStockSpider(scrapy.Spider):
name = "TencentStock"
def start_requests(self):
urls = [
'http://stock.qq.com/l/stock/yw ... 39%3B,
]
for url in urls:
yield SplashRequest(url, self.parse, args={'wait': 0.5})
def parse(self,response):
sel = scrapy.Selector(response)
links = sel.xpath("//div[@class='qq_main']//ul[@class='listInfo']//li//div[@class='info']//h3//a/@href").extract()
requests = []
for link in links:
request = scrapy.Request(link, callback =self.parse_article)
requests.append(request)
return requests
def parse_article(self,response):
sel = scrapy.Selector(response)
article = ArticleItem()
article['title'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/h1/text()').extract()[0]
article['source'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/div/div[1]/span[2]').xpath('string(.)').extract()[0]
article['pub_time'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/div/div[1]/span[3]/text()').extract()[0]
html_content = sel.xpath('//*[@id="Cnt-Main-Article-QQ"]').extract()[0]
article['content'] = self.remove_html_tags(html_content)
return article
def remove_html_tags(self,html):
soup = BeautifulSoup(html)
[s.extract() for s in soup('script')]
[s.extract() for s in soup('style')]
content = ''
for substring in soup.stripped_strings:
content = content + substring
return content
主要代码就一句话，将获取的页面发送到本地Splash实例进行渲染解析，最后将结果返回给parse函数进行解析
SplashRequest(url, self.parse, args={'wait': 0.5})
BeautifulSoup 库用于去除 html 中的 script 和 style 标签。具体用法可以参考这两篇文章文章：
Python爬虫第二把武器Beautiful Soup的用法
使用 BeautifulSoup 删除 html 中的脚本和注释
输出结果：
查看全部
)
随着越来越多的网站开始在客户端浏览器中使用JS动态渲染网站，很多我们需要的数据无法从原创html中获取，加上Scrapy不提供JS渲染和解析的功能。通常，我们一般使用两种方法来爬取这种类型的网站数据：
通过分析网站，找到数据对应的接口，模拟接口获取我们需要的数据（见Scrapy抓取Ajax动态页面），但是一旦网站的接口被隐藏深入，或者接口的加密太复杂，这种方法可能行不通。在JS内核的帮助下，将得到的收录JS脚本的页面交给JS内核进行渲染，最后将渲染后生成的html返回给Scrapy进行分析，这是比较常见的WebKit和Scrapy-Splash
本文文章的目的是介绍如何使用Scrapy-Splash用Scrapy爬取动态页面。
准备
Docker安装，具体安装步骤请参考Docker官网
为什么要安装 Docker？
由于Scrapy-Splash使用Splash HTTP API，需要提供Splash实例，并且Docker镜像中已经存在Splash实例，可以方便的使用。
Docker镜像源变更，参考国内docker仓库镜像对比
安装并运行 Splash
docker pull scrapinghub/splash #从docker镜像中拉取splash实例
docker run -p 8050:8050 scrapinghub/splash #启动splash实例
Scrapy 配置
在 Scrapy 项目的 setting.py 中添加以下内容：
SPLASH_URL = 'http://localhost:8050'
DOWNLOADER_MIDDLEWARES = {
'scrapy_splash.SplashCookiesMiddleware': 723,
'scrapy_splash.SplashMiddleware': 725,
'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 810,
}
SPIDER_MIDDLEWARES = {
'scrapy_splash.SplashDeduplicateArgsMiddleware': 100,
}
DUPEFILTER_CLASS = 'scrapy_splash.SplashAwareDupeFilter'
HTTPCACHE_STORAGE = 'scrapy_splash.SplashAwareFSCacheStorage'
实际代码分析
我们以腾讯证券页面为例。腾讯证券新闻列表是js动态渲染的
我们直接打开这个链接，然后打开开发者工具，找到新闻列表：
当我们查看网络第一个请求的Response时，发现返回的html中的列表页是空的
实际数据隐藏在JS中，加载完成后通过JS操作完成DOM插入
因为这里实际数据是塞进了一个JS变量中，并不是通过Ajax调用接口获取的，所以为了避免手动拦截JS变量，我们将页面交给Scrapy-Splash进行渲染
import scrapy
from FinancialInfoSpider.items import ArticleItem
from scrapy_splash import SplashRequest
from w3lib.html import remove_tags
import re
from bs4 import BeautifulSoup
class TencentStockSpider(scrapy.Spider):
name = "TencentStock"
def start_requests(self):
urls = [
'http://stock.qq.com/l/stock/yw ... 39%3B,
]
for url in urls:
yield SplashRequest(url, self.parse, args={'wait': 0.5})
def parse(self,response):
sel = scrapy.Selector(response)
links = sel.xpath("//div[@class='qq_main']//ul[@class='listInfo']//li//div[@class='info']//h3//a/@href").extract()
requests = []
for link in links:
request = scrapy.Request(link, callback =self.parse_article)
requests.append(request)
return requests
def parse_article(self,response):
sel = scrapy.Selector(response)
article = ArticleItem()
article['title'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/h1/text()').extract()[0]
article['source'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/div/div[1]/span[2]').xpath('string(.)').extract()[0]
article['pub_time'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/div/div[1]/span[3]/text()').extract()[0]
html_content = sel.xpath('//*[@id="Cnt-Main-Article-QQ"]').extract()[0]
article['content'] = self.remove_html_tags(html_content)
return article
def remove_html_tags(self,html):
soup = BeautifulSoup(html)
[s.extract() for s in soup('script')]
[s.extract() for s in soup('style')]
content = ''
for substring in soup.stripped_strings:
content = content + substring
return content
主要代码就一句话，将获取的页面发送到本地Splash实例进行渲染解析，最后将结果返回给parse函数进行解析
SplashRequest(url, self.parse, args={'wait': 0.5})
BeautifulSoup 库用于去除 html 中的 script 和 style 标签。具体用法可以参考这两篇文章文章：
Python爬虫第二把武器Beautiful Soup的用法
使用 BeautifulSoup 删除 html 中的脚本和注释
输出结果：
查看全部
scrapy分页抓取网页(国内docker仓库镜像对比安装运行Splash.jsJS渲染解析
)
随着越来越多的网站开始在客户端浏览器中使用JS动态渲染网站，很多我们需要的数据无法从原创html中获取，加上Scrapy不提供JS渲染和解析的功能。通常，我们一般使用两种方法来爬取这种类型的网站数据：
通过分析网站，找到数据对应的接口，模拟接口获取我们需要的数据（见Scrapy抓取Ajax动态页面），但是一旦网站的接口被隐藏深入，或者接口的加密太复杂，这种方法可能行不通。在JS内核的帮助下，将得到的收录JS脚本的页面交给JS内核进行渲染，最后将渲染后生成的html返回给Scrapy进行分析，这是比较常见的WebKit和Scrapy-Splash
本文文章的目的是介绍如何使用Scrapy-Splash用Scrapy爬取动态页面。
准备
Docker安装，具体安装步骤请参考Docker官网
为什么要安装 Docker？
由于Scrapy-Splash使用Splash HTTP API，需要提供Splash实例，并且Docker镜像中已经存在Splash实例，可以方便的使用。
Docker镜像源变更，参考国内docker仓库镜像对比
安装并运行 Splash
docker pull scrapinghub/splash #从docker镜像中拉取splash实例
docker run -p 8050:8050 scrapinghub/splash #启动splash实例
Scrapy 配置
在 Scrapy 项目的 setting.py 中添加以下内容：
SPLASH_URL = 'http://localhost:8050'
DOWNLOADER_MIDDLEWARES = {
'scrapy_splash.SplashCookiesMiddleware': 723,
'scrapy_splash.SplashMiddleware': 725,
'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 810,
}
SPIDER_MIDDLEWARES = {
'scrapy_splash.SplashDeduplicateArgsMiddleware': 100,
}
DUPEFILTER_CLASS = 'scrapy_splash.SplashAwareDupeFilter'
HTTPCACHE_STORAGE = 'scrapy_splash.SplashAwareFSCacheStorage'
实际代码分析
我们以腾讯证券页面为例。腾讯证券新闻列表是js动态渲染的
我们直接打开这个链接，然后打开开发者工具，找到新闻列表：
当我们查看网络第一个请求的Response时，发现返回的html中的列表页是空的
实际数据隐藏在JS中，加载完成后通过JS操作完成DOM插入
因为这里实际数据是塞进了一个JS变量中，并不是通过Ajax调用接口获取的，所以为了避免手动拦截JS变量，我们将页面交给Scrapy-Splash进行渲染
import scrapy
from FinancialInfoSpider.items import ArticleItem
from scrapy_splash import SplashRequest
from w3lib.html import remove_tags
import re
from bs4 import BeautifulSoup
class TencentStockSpider(scrapy.Spider):
name = "TencentStock"
def start_requests(self):
urls = [
'http://stock.qq.com/l/stock/yw ... 39%3B,
]
for url in urls:
yield SplashRequest(url, self.parse, args={'wait': 0.5})
def parse(self,response):
sel = scrapy.Selector(response)
links = sel.xpath("//div[@class='qq_main']//ul[@class='listInfo']//li//div[@class='info']//h3//a/@href").extract()
requests = []
for link in links:
request = scrapy.Request(link, callback =self.parse_article)
requests.append(request)
return requests
def parse_article(self,response):
sel = scrapy.Selector(response)
article = ArticleItem()
article['title'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/h1/text()').extract()[0]
article['source'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/div/div[1]/span[2]').xpath('string(.)').extract()[0]
article['pub_time'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/div/div[1]/span[3]/text()').extract()[0]
html_content = sel.xpath('//*[@id="Cnt-Main-Article-QQ"]').extract()[0]
article['content'] = self.remove_html_tags(html_content)
return article
def remove_html_tags(self,html):
soup = BeautifulSoup(html)
[s.extract() for s in soup('script')]
[s.extract() for s in soup('style')]
content = ''
for substring in soup.stripped_strings:
content = content + substring
return content
主要代码就一句话，将获取的页面发送到本地Splash实例进行渲染解析，最后将结果返回给parse函数进行解析
SplashRequest(url, self.parse, args={'wait': 0.5})
BeautifulSoup 库用于去除 html 中的 script 和 style 标签。具体用法可以参考这两篇文章文章：
Python爬虫第二把武器Beautiful Soup的用法
使用 BeautifulSoup 删除 html 中的脚本和注释
输出结果：
scrapy分页抓取网页(内建函数parseRequest请求获取新网页内容进一步处理，获爬取处理)
网站优化 • 优采云 发表了文章 • 0 个评论 • 48 次浏览 • 2022-02-03 17:28
scrapy分页抓取网页(内建函数parseRequest请求获取新网页内容进一步处理，获爬取处理)
因为最初抓取的网站是一个href，所以需要跳转到它，也就是发送一个Request
你好
这是我的代码：
def parse(self, response):
href_set = []
list = response.xpath("//div[@style='display:none;']//li/a/@href").extract() #获取href
for i in range(0, 50, 1): # 留下前50条数据
href_set.append(list[i])
for href in href_set:
yield scrapy.Request(url=href, callback=self.new_parse)
#就是这个Request请求了一个新的url，完成之后回调new_parse函数，进一步处理
def new_parse(self, response):
myitem = TutorialItem()
myitem['article_title'] = response.xpath("//h1[@class='main-title']/text()").extract()
myitem['article_content'] = response.xpath("//div[@class='article']//p/text()").extract()
# 获取第一张图片，可能无图
myitem['article_image'] = response.xpath("//div[@class='img_wrapper']//img/@src").extract_first()
# 把自己的item抛出给pipeline
yield myitem
总体思路是通过parse的自动调用获取href，然后使用Request请求获取新的网页内容进行进一步处理。
如果要爬取的网页有n层href，则调用Request n次，直到爬取到要获取数据的网页，否则保持Request和跳转访问（我的只有一层）href，即调整href一次）
其实内置函数parse的原理是类似的 查看全部
因为最初抓取的网站是一个href，所以需要跳转到它，也就是发送一个Request
你好
这是我的代码：
def parse(self, response):
href_set = []
list = response.xpath("//div[@style='display:none;']//li/a/@href").extract() #获取href
for i in range(0, 50, 1): # 留下前50条数据
href_set.append(list[i])
for href in href_set:
yield scrapy.Request(url=href, callback=self.new_parse)
#就是这个Request请求了一个新的url，完成之后回调new_parse函数，进一步处理
def new_parse(self, response):
myitem = TutorialItem()
myitem['article_title'] = response.xpath("//h1[@class='main-title']/text()").extract()
myitem['article_content'] = response.xpath("//div[@class='article']//p/text()").extract()
# 获取第一张图片，可能无图
myitem['article_image'] = response.xpath("//div[@class='img_wrapper']//img/@src").extract_first()
# 把自己的item抛出给pipeline
yield myitem
总体思路是通过parse的自动调用获取href，然后使用Request请求获取新的网页内容进行进一步处理。
如果要爬取的网页有n层href，则调用Request n次，直到爬取到要获取数据的网页，否则保持Request和跳转访问（我的只有一层）href，即调整href一次）
其实内置函数parse的原理是类似的 查看全部
scrapy分页抓取网页(内建函数parseRequest请求获取新网页内容进一步处理，获爬取处理)
因为最初抓取的网站是一个href，所以需要跳转到它，也就是发送一个Request
你好
这是我的代码：
def parse(self, response):
href_set = []
list = response.xpath("//div[@style='display:none;']//li/a/@href").extract() #获取href
for i in range(0, 50, 1): # 留下前50条数据
href_set.append(list[i])
for href in href_set:
yield scrapy.Request(url=href, callback=self.new_parse)
#就是这个Request请求了一个新的url，完成之后回调new_parse函数，进一步处理
def new_parse(self, response):
myitem = TutorialItem()
myitem['article_title'] = response.xpath("//h1[@class='main-title']/text()").extract()
myitem['article_content'] = response.xpath("//div[@class='article']//p/text()").extract()
# 获取第一张图片，可能无图
myitem['article_image'] = response.xpath("//div[@class='img_wrapper']//img/@src").extract_first()
# 把自己的item抛出给pipeline
yield myitem
总体思路是通过parse的自动调用获取href，然后使用Request请求获取新的网页内容进行进一步处理。
如果要爬取的网页有n层href，则调用Request n次，直到爬取到要获取数据的网页，否则保持Request和跳转访问（我的只有一层）href，即调整href一次）
其实内置函数parse的原理是类似的
scrapy分页抓取网页( WebScraper怎么对付这种类型的网页翻页?(图))
网站优化 • 优采云 发表了文章 • 0 个评论 • 60 次浏览 • 2022-02-03 08:19
scrapy分页抓取网页(
WebScraper怎么对付这种类型的网页翻页?(图))
这是简易数据分析系列文章的第12期。html
在之前的文章中文章我们介绍了Web Scraper处理各种页面翻转的解决方案，比如修改网页连接加载数据，点击“更多按钮”加载数据，下拉自动加载数据。今天我们讲一种比较常见的翻页方式——pager。网络
本来想解释一下什么是pager，但是看了一堆定义，觉得很麻烦。你不是第一年上网，看图就知道了。我找到了一个功能齐全的例子，支持数字页码调整，上一页到下一页和指定页数跳转。邮政
今天我们将学习 Web Scraper 如何处理这种类型的翻页。温泉
事实上，在本教程的第一个示例中，我们就抓取了豆瓣电影 TOP 榜单。这个豆瓣电影列表使用寻呼机来划分数据：代码
但是当时我们是在寻找网页连接规则来爬取，并没有使用pager来爬取。因为当一个网页的连接有规律的变化时，控制连接参数捕获是成本最低的；如果网页可以翻页，但是连接的变化不规律，就得去pager了一会儿。视频
说这些理论有点无聊，我们举个不规则翻页连接的例子。htm
8月2日是蔡徐坤的生日。为了庆祝，微博上的粉丝给了坤坤300W的转发。微博的转发数据恰好被寻呼机分割。我们来分析一下微博的转发。信息页面，了解如何使用 Web Scraper 抓取此类数据。博客
这条微博的直接链接是：教程
元素
看了这么多他的视频，为了表达我们的感激之情，我们可以点进点出给坤坤加个阅读。
首先我们看一下第1页转发的连接，长这样：
第二页是这样的，我注意到有一个额外的#_rnd36 参数：
第三页参数为#_rnd39
第 4 页参数是#_rnd76：
又看了几个链接，发现这个转发页面的url没有规则，只能通过pager翻页加载数据。让我们开始我们的实践教学课程。
1.创建站点地图
我们首先创建一个SiteMap，这个时候命名为cxk，初始连接是。
2.为容器创建一个选择器
由于我们要点击pager，所以我们选择外层容器的类型为Element Click。具体参数说明见下图。我们之前在《简单数据分析08》中详细讲解过，这里就不多说了。
容器的预览如下图所示：
寻呼机选择过程如下图所示：
3.创建子选择器
这些子选择器比较简单，类型都是文本选择器。我们选择了三种类型的内容：评论用户名、评论内容和评论时间。
4.捕获数据
可以根据Sitemap cxk -> Scrape 的操作路径抓取数据。
5.一些问题
如果你看了我上面的教程，马上爬数据，你可能遇到的第一个问题是，300w数据，我是不是都爬下来了？
听起来很不现实。毕竟Web Scraper针对的数据量比较少，上万的数据算太多了。不管数据有多大，都要考虑爬取时间是否过长，数据如何存储，如何处理。网站的反爬系统（比如突然弹出一个验证码，这个Web Scraper无能为力）。
考虑到这个问题，如果你看过上一篇关于自动控制抓取次数的教程，你可能会想到使用 :nth-of-type(-n+N) 来控制 N 条数据的抓取。如果你尝试一下，你会发现这个方法根本行不通。
失败的原因其实涉及到一点网页知识。如果您有兴趣，可以阅读下面的说明。不感兴趣的可以直接看最后的结论。
就像我之前介绍的更多加载页面和下拉加载页面一样，它们新加载的数据会附加到当前页面。表示所有数据都在同一页面上。
当我们使用：nth-of-type(-n+N)来控制加载次数的时候，其实就是在这个网页上设置一个计数器。当数据已经累积到我们想要的数量时，就会停止爬取。
但是，对于使用寻呼机的网页，每次翻页到刷新当前网页时，都会设置一个计数器。
比如你要抓1000条数据，但是第一页只有20条数据，抓到最后一条，还有980条数据；对于一条数据，还有980，一翻页计数器就清零，又变成1000了……所以这种控制数量的方法是无效的。
所以得出的结论是，寻呼机类型的网页如果想要提前结束爬取，唯一的办法就是断网。当然，如果你有更好的解决方案，可以在评论中回复我，我们可以互相讨论。
6.总结
分页器是一种非常常见的网页分页方法。我们可以通过 Web Scraper 中的 Element click 处理此类网页，并通过断开网络来结束爬取。 查看全部
WebScraper怎么对付这种类型的网页翻页?(图))
这是简易数据分析系列文章的第12期。html
在之前的文章中文章我们介绍了Web Scraper处理各种页面翻转的解决方案，比如修改网页连接加载数据，点击“更多按钮”加载数据，下拉自动加载数据。今天我们讲一种比较常见的翻页方式——pager。网络
本来想解释一下什么是pager，但是看了一堆定义，觉得很麻烦。你不是第一年上网，看图就知道了。我找到了一个功能齐全的例子，支持数字页码调整，上一页到下一页和指定页数跳转。邮政
今天我们将学习 Web Scraper 如何处理这种类型的翻页。温泉
事实上，在本教程的第一个示例中，我们就抓取了豆瓣电影 TOP 榜单。这个豆瓣电影列表使用寻呼机来划分数据：代码
但是当时我们是在寻找网页连接规则来爬取，并没有使用pager来爬取。因为当一个网页的连接有规律的变化时，控制连接参数捕获是成本最低的；如果网页可以翻页，但是连接的变化不规律，就得去pager了一会儿。视频
说这些理论有点无聊，我们举个不规则翻页连接的例子。htm
8月2日是蔡徐坤的生日。为了庆祝，微博上的粉丝给了坤坤300W的转发。微博的转发数据恰好被寻呼机分割。我们来分析一下微博的转发。信息页面，了解如何使用 Web Scraper 抓取此类数据。博客
这条微博的直接链接是：教程
元素
看了这么多他的视频，为了表达我们的感激之情，我们可以点进点出给坤坤加个阅读。
首先我们看一下第1页转发的连接，长这样：
第二页是这样的，我注意到有一个额外的#_rnd36 参数：
第三页参数为#_rnd39
第 4 页参数是#_rnd76：
又看了几个链接，发现这个转发页面的url没有规则，只能通过pager翻页加载数据。让我们开始我们的实践教学课程。
1.创建站点地图
我们首先创建一个SiteMap，这个时候命名为cxk，初始连接是。
2.为容器创建一个选择器
由于我们要点击pager，所以我们选择外层容器的类型为Element Click。具体参数说明见下图。我们之前在《简单数据分析08》中详细讲解过，这里就不多说了。
容器的预览如下图所示：
寻呼机选择过程如下图所示：
3.创建子选择器
这些子选择器比较简单，类型都是文本选择器。我们选择了三种类型的内容：评论用户名、评论内容和评论时间。
4.捕获数据
可以根据Sitemap cxk -> Scrape 的操作路径抓取数据。
5.一些问题
如果你看了我上面的教程，马上爬数据，你可能遇到的第一个问题是，300w数据，我是不是都爬下来了？
听起来很不现实。毕竟Web Scraper针对的数据量比较少，上万的数据算太多了。不管数据有多大，都要考虑爬取时间是否过长，数据如何存储，如何处理。网站的反爬系统（比如突然弹出一个验证码，这个Web Scraper无能为力）。
考虑到这个问题，如果你看过上一篇关于自动控制抓取次数的教程，你可能会想到使用 :nth-of-type(-n+N) 来控制 N 条数据的抓取。如果你尝试一下，你会发现这个方法根本行不通。
失败的原因其实涉及到一点网页知识。如果您有兴趣，可以阅读下面的说明。不感兴趣的可以直接看最后的结论。
就像我之前介绍的更多加载页面和下拉加载页面一样，它们新加载的数据会附加到当前页面。表示所有数据都在同一页面上。
当我们使用：nth-of-type(-n+N)来控制加载次数的时候，其实就是在这个网页上设置一个计数器。当数据已经累积到我们想要的数量时，就会停止爬取。
但是，对于使用寻呼机的网页，每次翻页到刷新当前网页时，都会设置一个计数器。
比如你要抓1000条数据，但是第一页只有20条数据，抓到最后一条，还有980条数据；对于一条数据，还有980，一翻页计数器就清零，又变成1000了……所以这种控制数量的方法是无效的。
所以得出的结论是，寻呼机类型的网页如果想要提前结束爬取，唯一的办法就是断网。当然，如果你有更好的解决方案，可以在评论中回复我，我们可以互相讨论。
6.总结
分页器是一种非常常见的网页分页方法。我们可以通过 Web Scraper 中的 Element click 处理此类网页，并通过断开网络来结束爬取。 查看全部
scrapy分页抓取网页(
WebScraper怎么对付这种类型的网页翻页?(图))
这是简易数据分析系列文章的第12期。html
在之前的文章中文章我们介绍了Web Scraper处理各种页面翻转的解决方案，比如修改网页连接加载数据，点击“更多按钮”加载数据，下拉自动加载数据。今天我们讲一种比较常见的翻页方式——pager。网络
本来想解释一下什么是pager，但是看了一堆定义，觉得很麻烦。你不是第一年上网，看图就知道了。我找到了一个功能齐全的例子，支持数字页码调整，上一页到下一页和指定页数跳转。邮政
今天我们将学习 Web Scraper 如何处理这种类型的翻页。温泉
事实上，在本教程的第一个示例中，我们就抓取了豆瓣电影 TOP 榜单。这个豆瓣电影列表使用寻呼机来划分数据：代码
但是当时我们是在寻找网页连接规则来爬取，并没有使用pager来爬取。因为当一个网页的连接有规律的变化时，控制连接参数捕获是成本最低的；如果网页可以翻页，但是连接的变化不规律，就得去pager了一会儿。视频
说这些理论有点无聊，我们举个不规则翻页连接的例子。htm
8月2日是蔡徐坤的生日。为了庆祝，微博上的粉丝给了坤坤300W的转发。微博的转发数据恰好被寻呼机分割。我们来分析一下微博的转发。信息页面，了解如何使用 Web Scraper 抓取此类数据。博客
这条微博的直接链接是：教程
元素
看了这么多他的视频，为了表达我们的感激之情，我们可以点进点出给坤坤加个阅读。
首先我们看一下第1页转发的连接，长这样：
第二页是这样的，我注意到有一个额外的#_rnd36 参数：
第三页参数为#_rnd39
第 4 页参数是#_rnd76：
又看了几个链接，发现这个转发页面的url没有规则，只能通过pager翻页加载数据。让我们开始我们的实践教学课程。
1.创建站点地图
我们首先创建一个SiteMap，这个时候命名为cxk，初始连接是。
2.为容器创建一个选择器
由于我们要点击pager，所以我们选择外层容器的类型为Element Click。具体参数说明见下图。我们之前在《简单数据分析08》中详细讲解过，这里就不多说了。
容器的预览如下图所示：
寻呼机选择过程如下图所示：
3.创建子选择器
这些子选择器比较简单，类型都是文本选择器。我们选择了三种类型的内容：评论用户名、评论内容和评论时间。
4.捕获数据
可以根据Sitemap cxk -> Scrape 的操作路径抓取数据。
5.一些问题
如果你看了我上面的教程，马上爬数据，你可能遇到的第一个问题是，300w数据，我是不是都爬下来了？
听起来很不现实。毕竟Web Scraper针对的数据量比较少，上万的数据算太多了。不管数据有多大，都要考虑爬取时间是否过长，数据如何存储，如何处理。网站的反爬系统（比如突然弹出一个验证码，这个Web Scraper无能为力）。
考虑到这个问题，如果你看过上一篇关于自动控制抓取次数的教程，你可能会想到使用 :nth-of-type(-n+N) 来控制 N 条数据的抓取。如果你尝试一下，你会发现这个方法根本行不通。
失败的原因其实涉及到一点网页知识。如果您有兴趣，可以阅读下面的说明。不感兴趣的可以直接看最后的结论。
就像我之前介绍的更多加载页面和下拉加载页面一样，它们新加载的数据会附加到当前页面。表示所有数据都在同一页面上。
当我们使用：nth-of-type(-n+N)来控制加载次数的时候，其实就是在这个网页上设置一个计数器。当数据已经累积到我们想要的数量时，就会停止爬取。
但是，对于使用寻呼机的网页，每次翻页到刷新当前网页时，都会设置一个计数器。
比如你要抓1000条数据，但是第一页只有20条数据，抓到最后一条，还有980条数据；对于一条数据，还有980，一翻页计数器就清零，又变成1000了……所以这种控制数量的方法是无效的。
所以得出的结论是，寻呼机类型的网页如果想要提前结束爬取，唯一的办法就是断网。当然，如果你有更好的解决方案，可以在评论中回复我，我们可以互相讨论。
6.总结
分页器是一种非常常见的网页分页方法。我们可以通过 Web Scraper 中的 Element click 处理此类网页，并通过断开网络来结束爬取。
scrapy分页抓取网页(2.3、Getamp常见的请求方法有两种(组图))
网站优化 • 优采云 发表了文章 • 0 个评论 • 299 次浏览 • 2022-02-18 09:07
scrapy分页抓取网页(2.3、Getamp常见的请求方法有两种(组图))
HTTPS 的安全基础是 SSL，所以通过它传输的内容是经过 SSL 加密的。它的主要功能可以分为两种。
2.3、获取并发布
有两种常见的请求方法：GET 和 POST。
直接在浏览器中输入URL回车，发起GET请求，请求的参数会直接收录在URL中。比如在百度搜索Python，这是一个GET请求，链接为/s?wd=Python，其中url收录请求的参数信息，其中参数wd代表要搜索的关键字。 GET 请求正文为空。 POST 请求主要是在提交表单时发出的。比如登录表单，输入用户名和密码后，点击“登录”按钮，一般会发起POST请求，数据一般以表单的形式传输，不体现在URL中。
GET 和 POST 请求方法有以下区别。
一般来说，登录时需要提交用户名和密码，其中收录敏感信息。如果使用 GET 方式请求，会在 URL 中暴露密码，导致密码泄露，所以最好通过 POST 发送。上传文件时，由于文件内容比较大，也使用POST方式。
2.4、爬虫定义
简单来说，爬虫是一个自动程序，它获取网页并提取和保存信息。
最关键的部分是构造一个请求并将其发送到服务器，然后接收并解析响应。
2.5、会话和 Cookie
HTTP的无状态意味着HTTP协议没有用于事务处理的内存能力，这意味着服务器不知道客户端处于什么状态。当我们向服务器发送请求时，服务器会解析请求，然后返回相应的响应。服务器负责完成这个过程，这个过程是完全独立的。服务器不会记录前后状态的变化，即缺少状态记录。这意味着如果前面的信息需要在后面进行处理，就必须重传，这就导致需要通过一些额外的前面的重复请求才能获得后续的响应，但是这样的效果显然不是我们想要的。为了保持前后的状态，千万不能把之前所有的请求都重传一次，这样太浪费资源了，对于这种需要用户登录的页面更是难上加难。
有两种技术可用于维护 HTTP 连接的状态，会话和 cookie。 session在服务端，即网站的服务端，用来保存用户的session信息；客户端的cookies也可以理解为浏览器端。使用 cookie，浏览器会自动将其附加到下一页访问。发送到服务器后，服务器通过识别Cookies来识别用户，进而判断用户是否处于登录状态，然后返回相应的响应。
我们可以理解，登录凭据存储在 cookie 中。有了它，您只需在下一次请求中发送带有cookies的请求，无需重新输入用户名、密码等信息再次登录。
2.5.1、常见误区
在谈论会话机制时会听到一个常见的误解 - “一旦关闭浏览器，会话就会消失”。想象一下会员卡的例子。除非顾客主动要求店家注销卡，否则店家绝不会轻易删除顾客的资料。会话也是如此，除非程序告诉服务器删除会话，否则服务器会保留它。比如我们在进行注销操作时，程序一般会删除会话。
但是当我们关闭浏览器时，浏览器并没有在关闭前主动通知服务器即将关闭，所以服务器根本没有机会知道浏览器已经关闭。产生这种错觉的原因是大部分会话机制使用会话cookie来保存会话ID信息，而cookie在关闭浏览器后消失。再次连接服务器时，找不到原来的会话。如果服务器设置的cookies保存到硬盘，或者浏览器发送的HTTP请求头通过某种方式被改写，将原来的cookies发送给服务器，那么可以再次打开浏览器，原来的会话ID仍然可以找到，仍然可以维护。登录状态。
而正是因为关闭浏览器不会导致会话被删除，这就需要服务器为会话设置一个过期时间。当自客户端上次使用会话以来的时间超过此过期时间时，服务器可以考虑在活动停止时删除客户端会话以节省存储空间。
3、基本操作
# 普通 GET 请求
response = urllib.request.urlopen('https://www.python.org')
print(response.read().decode('utf-8'))
# POST 请求
# 这里我们传递了一个参数 word, 值是 hello, 它需要被转码成 bytes（字节流）类型
# 而转字节流采用了 bytes 方法，该方法的第一个参数需要是 str（字符串）类型
data = bytes(urllib.parse.urlencode({'word' : 'hello'}), encoding ＝ 'utf8')
# 还有 timeout 设置超时参数
# cafile 和 capath 这两个参数分别指定 CA 证书和它的路径
response = urllib.request.urlopen('http://httpbin.org/post', data = data)
# request 更多的控制参数
# headers 参数通常是设置 User-Agent 来伪装浏览器
# method 代表 GET、POST 等
urllib.request.Request(url, data=None, headers={}, origin_req_host=None, unverifiable=False, method=None)
3.1、高级操作
# urllib.request 模块里的 BaseHandler 类可以处理 Cookies 等高级操作
# 比如下图的需要身份验证
from urllib.request import HTTPPasswordMgrWithDefaultRealm, HTTPBasicAuthHandler, build_opener
from urllib.error import URLError
username = username
password = 'password'
url = 'http://localhost:5000/'
p = HTTPPasswordMgrWithDefaultRealm()
p.add_password(None, url, username, password)
auth_handler = HTTPBasicAuthHandler(p)
opener = build_opener(auth_handler)
try:
result = opener.open(url)
html = result.read().decode('utf8')
print(html)
except URLError as e:
print(e.reason)
# 设置代理
proxy_handler = ProxyHandler({
'http' : 'http://127.0.0.1:9743',
'https': 'https://127.0.0.1:9743'
})
opener = build_opener(proxy_handler)
# 设置 Cookies
cookie = http.cookiejar.CookieJar()
handler = urllib.request.HTTPCookieProcessor(cookie)
opener = urllib.request.build_opener(handler)
response = opener.open('http://www.baidu.com')
# request 库设置 Cookies，request 库可以直接把 Cookie 参数放到 headers 里
r = requests.get('https://www.baidu.com')
# 从中可以看出 Cookie 的类型
print(r.cookies)
for key, value in r.cookies.items():
print(key + '=' + value)
# urlparse() 可以实现 URL 的识别和分段
# quote() 可以将中文字符串转化为 URL 编码
# 对应 unquote() 就是反过来
# 身份验证
r = requests.get('http://localhost:5000', auth＝('username', 'password'))
3.1.1、处理二进制数据
# 下载文件
import requests
r = requests.get('https://github.com/favicon.ic'）
with open('favicon.ico', 'wb') as f:
f.write(r.content)
# 上传文件
files = {'file' : open('favicon.ico', 'rb')}
r = requests.post('http://httpbin.org/post', files=files)
3.2、机器人协议
Robots 协议也称为爬虫协议和机器人协议。它的全称是Robots Exclusion Protocol，用于告诉爬虫和搜索引擎哪些页面可以爬取，哪些页面不能爬取。它通常是一个名为 robots.txt 的文本文件，通常放在 网站 的根目录下。
搜索爬虫访问网站时，首先会检查网站根目录下是否有robots.txt文件。如果存在，搜索爬虫将根据其中定义的爬取范围进行爬取。如果没有找到该文件，搜索爬虫将访问所有可直接访问的页面。
User-agent: *
Disallow: /
Allow: /public/
上述案例的文件内容表示所有搜索爬虫只允许爬取公共目录。
User-agent用于设置爬虫的名称，*表示适用于所有。
disallow代表不能爬取的目录，/代表禁止爬取所有页面。
# 传入 robots.txt 文件的链接即可解析
urllib.robotparser.RobotFileParser(url='')
print(rp.can_fetch('*', 'http://www.jianshu.com/p/b67554025d7d'))
3.3、会话维护
在请求中，如果直接使用get或post等方法，确实可以模拟网页请求，但这实际上相当于不同的会话，也就是说你使用两个浏览器打开不同的页面。
想象这样一个场景，第一次请求使用post方法登录某个网站，第二次登录成功后想获取自己的个人信息，再次使用get方法请求个人信息页面。其实这相当于打开了两个浏览器，两个完全不相关的会话。能否成功获取个人信息？当然不是。
你们中的一些人可能说过我可以为两个请求设置相同的 cookie，对吧？是的，但是这样做很麻烦，而且我们有一个更简单的解决方案。
其实这个问题的主要解决方案是保持同一个会话，相当于打开一个新的浏览器标签而不是打开一个新的浏览器。但是我不想每次都设置cookies，我该怎么办？这时候就有了新的武器——Session对象。
s = requests.Session()
s.get('http://httpbin.org/cookies/set ... %2339;)
r = s.get('http://httpbin.org/cookies')
3.4、使用代理
对于一些网站，在测试过程中多次请求后可以正常获取内容。但是一旦开始大规模爬取，对于大规模频繁的请求，网站可能会弹出验证码，或者跳转到登录认证页面，甚至直接屏蔽客户端IP，造成一定的周期的时间。内部无法访问。
import requests
proxies = {
"http" : "http://10.10.1.10:3128",
"https" : "http://10.10.1.10:1080",
}
requests.get("https://www.taobao.com", proxies=proxies)
4、动态渲染数据爬取
有时当我们抓取带有请求的页面时，结果可能与我们在浏览器中看到的不同：
在浏览器中可以看到页面数据正常显示，但是使用requests得到的结果却不是。这是因为请求都是原创的 HTML 文档，而浏览器中的页面是通过 JavaScript 处理数据的结果。这些数据有多种来源，可以通过 Ajax 加载或收录在 HTML 中。在文档中，也可能是由 JavaScript 和特定算法生成的。
对于第一种情况，数据加载是一种异步加载方式。最初的页面不会收录一些数据。原创页面加载完成后，会向服务器请求一个接口获取数据，然后再加载数据。处理并渲染到网页，其实就是发送一个ajax请求。
根据Web的发展趋势，这种形式的页面越来越多。网页的原创HTML文档不收录任何数据，数据通过Ajax统一加载后显示，这样在Web开发中可以分离前后端，以及服务器带来的压力减少直接渲染页面。
所以遇到这样的页面，直接使用requests等库抓取原创页面是无法获取有效数据的。这时候就需要分析网页后端向接口发送的Ajax请求了。如果可以使用requests来模拟ajax请求，那么就可以成功爬取了。
4.1、Ajax 定义
Ajax，全称是Asynchronous JavaScript and XML，即异步JavaScript XML，它不是一种编程语言，而是使用JavaScript与服务器交换数据，更新一些网页而不刷新页面和页面链接不变。技术。
对于一个传统的网页，如果要更新它的内容，就必须刷新整个页面，但是使用Ajax，你可以在不刷新整个页面的情况下更新页面的内容。在这个过程中，页面实际上是在后台与服务器交互的。获取到数据后，通过JavaScript来改变网页，从而更新网页的内容。
4.2、Ajax 数据抓取
向网页更新发送Ajax请求的过程可以分为以下几个步骤：
1、发送请求
2、解析内容
3、渲染网页
通过开发者模式找到类型为XHR的请求，查看请求的url和请求体，并进行模拟。
并非所有页面都可以通过分析 Ajax 进行爬取。有些页面的参数比较复杂，可能收录加密密钥。很难自己构造参数。
通过直接模拟浏览器操作，无需关注这些界面参数。
4.3、页面动态渲染
但是，javaScript 动态呈现的页面并不局限于 Ajax。有些网页的分页部分是由 JavaScript 生成的，而不是原创的 HTML 代码，不收录 Ajax 请求。比如ECharts的官方实例，它的图形都是JavaScript计算后生成的。
为了解决这些问题，我们可以直接使用模拟浏览器操作的方式，这样就可以看到浏览器里面有什么，抓取到什么源码，也就是什么时候可以抓取它是可见的。 这样，我们就不再需要关心网页内部的 JavaScript 使用什么算法来渲染页面，也不需要关心网页后台的 Ajax 接口的参数。 查看全部
HTTPS 的安全基础是 SSL，所以通过它传输的内容是经过 SSL 加密的。它的主要功能可以分为两种。
2.3、获取并发布
有两种常见的请求方法：GET 和 POST。
直接在浏览器中输入URL回车，发起GET请求，请求的参数会直接收录在URL中。比如在百度搜索Python，这是一个GET请求，链接为/s?wd=Python，其中url收录请求的参数信息，其中参数wd代表要搜索的关键字。 GET 请求正文为空。 POST 请求主要是在提交表单时发出的。比如登录表单，输入用户名和密码后，点击“登录”按钮，一般会发起POST请求，数据一般以表单的形式传输，不体现在URL中。
GET 和 POST 请求方法有以下区别。
一般来说，登录时需要提交用户名和密码，其中收录敏感信息。如果使用 GET 方式请求，会在 URL 中暴露密码，导致密码泄露，所以最好通过 POST 发送。上传文件时，由于文件内容比较大，也使用POST方式。
2.4、爬虫定义
简单来说，爬虫是一个自动程序，它获取网页并提取和保存信息。
最关键的部分是构造一个请求并将其发送到服务器，然后接收并解析响应。
2.5、会话和 Cookie
HTTP的无状态意味着HTTP协议没有用于事务处理的内存能力，这意味着服务器不知道客户端处于什么状态。当我们向服务器发送请求时，服务器会解析请求，然后返回相应的响应。服务器负责完成这个过程，这个过程是完全独立的。服务器不会记录前后状态的变化，即缺少状态记录。这意味着如果前面的信息需要在后面进行处理，就必须重传，这就导致需要通过一些额外的前面的重复请求才能获得后续的响应，但是这样的效果显然不是我们想要的。为了保持前后的状态，千万不能把之前所有的请求都重传一次，这样太浪费资源了，对于这种需要用户登录的页面更是难上加难。
有两种技术可用于维护 HTTP 连接的状态，会话和 cookie。 session在服务端，即网站的服务端，用来保存用户的session信息；客户端的cookies也可以理解为浏览器端。使用 cookie，浏览器会自动将其附加到下一页访问。发送到服务器后，服务器通过识别Cookies来识别用户，进而判断用户是否处于登录状态，然后返回相应的响应。
我们可以理解，登录凭据存储在 cookie 中。有了它，您只需在下一次请求中发送带有cookies的请求，无需重新输入用户名、密码等信息再次登录。
2.5.1、常见误区
在谈论会话机制时会听到一个常见的误解 - “一旦关闭浏览器，会话就会消失”。想象一下会员卡的例子。除非顾客主动要求店家注销卡，否则店家绝不会轻易删除顾客的资料。会话也是如此，除非程序告诉服务器删除会话，否则服务器会保留它。比如我们在进行注销操作时，程序一般会删除会话。
但是当我们关闭浏览器时，浏览器并没有在关闭前主动通知服务器即将关闭，所以服务器根本没有机会知道浏览器已经关闭。产生这种错觉的原因是大部分会话机制使用会话cookie来保存会话ID信息，而cookie在关闭浏览器后消失。再次连接服务器时，找不到原来的会话。如果服务器设置的cookies保存到硬盘，或者浏览器发送的HTTP请求头通过某种方式被改写，将原来的cookies发送给服务器，那么可以再次打开浏览器，原来的会话ID仍然可以找到，仍然可以维护。登录状态。
而正是因为关闭浏览器不会导致会话被删除，这就需要服务器为会话设置一个过期时间。当自客户端上次使用会话以来的时间超过此过期时间时，服务器可以考虑在活动停止时删除客户端会话以节省存储空间。
3、基本操作
# 普通 GET 请求
response = urllib.request.urlopen('https://www.python.org')
print(response.read().decode('utf-8'))
# POST 请求
# 这里我们传递了一个参数 word, 值是 hello, 它需要被转码成 bytes（字节流）类型
# 而转字节流采用了 bytes 方法，该方法的第一个参数需要是 str（字符串）类型
data = bytes(urllib.parse.urlencode({'word' : 'hello'}), encoding ＝ 'utf8')
# 还有 timeout 设置超时参数
# cafile 和 capath 这两个参数分别指定 CA 证书和它的路径
response = urllib.request.urlopen('http://httpbin.org/post', data = data)
# request 更多的控制参数
# headers 参数通常是设置 User-Agent 来伪装浏览器
# method 代表 GET、POST 等
urllib.request.Request(url, data=None, headers={}, origin_req_host=None, unverifiable=False, method=None)
3.1、高级操作
# urllib.request 模块里的 BaseHandler 类可以处理 Cookies 等高级操作
# 比如下图的需要身份验证
from urllib.request import HTTPPasswordMgrWithDefaultRealm, HTTPBasicAuthHandler, build_opener
from urllib.error import URLError
username = username
password = 'password'
url = 'http://localhost:5000/'
p = HTTPPasswordMgrWithDefaultRealm()
p.add_password(None, url, username, password)
auth_handler = HTTPBasicAuthHandler(p)
opener = build_opener(auth_handler)
try:
result = opener.open(url)
html = result.read().decode('utf8')
print(html)
except URLError as e:
print(e.reason)
# 设置代理
proxy_handler = ProxyHandler({
'http' : 'http://127.0.0.1:9743',
'https': 'https://127.0.0.1:9743'
})
opener = build_opener(proxy_handler)
# 设置 Cookies
cookie = http.cookiejar.CookieJar()
handler = urllib.request.HTTPCookieProcessor(cookie)
opener = urllib.request.build_opener(handler)
response = opener.open('http://www.baidu.com')
# request 库设置 Cookies，request 库可以直接把 Cookie 参数放到 headers 里
r = requests.get('https://www.baidu.com')
# 从中可以看出 Cookie 的类型
print(r.cookies)
for key, value in r.cookies.items():
print(key + '=' + value)
# urlparse() 可以实现 URL 的识别和分段
# quote() 可以将中文字符串转化为 URL 编码
# 对应 unquote() 就是反过来
# 身份验证
r = requests.get('http://localhost:5000', auth＝('username', 'password'))
3.1.1、处理二进制数据
# 下载文件
import requests
r = requests.get('https://github.com/favicon.ic'）
with open('favicon.ico', 'wb') as f:
f.write(r.content)
# 上传文件
files = {'file' : open('favicon.ico', 'rb')}
r = requests.post('http://httpbin.org/post', files=files)
3.2、机器人协议
Robots 协议也称为爬虫协议和机器人协议。它的全称是Robots Exclusion Protocol，用于告诉爬虫和搜索引擎哪些页面可以爬取，哪些页面不能爬取。它通常是一个名为 robots.txt 的文本文件，通常放在 网站 的根目录下。
搜索爬虫访问网站时，首先会检查网站根目录下是否有robots.txt文件。如果存在，搜索爬虫将根据其中定义的爬取范围进行爬取。如果没有找到该文件，搜索爬虫将访问所有可直接访问的页面。
User-agent: *
Disallow: /
Allow: /public/
上述案例的文件内容表示所有搜索爬虫只允许爬取公共目录。
User-agent用于设置爬虫的名称，*表示适用于所有。
disallow代表不能爬取的目录，/代表禁止爬取所有页面。
# 传入 robots.txt 文件的链接即可解析
urllib.robotparser.RobotFileParser(url='')
print(rp.can_fetch('*', 'http://www.jianshu.com/p/b67554025d7d'))
3.3、会话维护
在请求中，如果直接使用get或post等方法，确实可以模拟网页请求，但这实际上相当于不同的会话，也就是说你使用两个浏览器打开不同的页面。
想象这样一个场景，第一次请求使用post方法登录某个网站，第二次登录成功后想获取自己的个人信息，再次使用get方法请求个人信息页面。其实这相当于打开了两个浏览器，两个完全不相关的会话。能否成功获取个人信息？当然不是。
你们中的一些人可能说过我可以为两个请求设置相同的 cookie，对吧？是的，但是这样做很麻烦，而且我们有一个更简单的解决方案。
其实这个问题的主要解决方案是保持同一个会话，相当于打开一个新的浏览器标签而不是打开一个新的浏览器。但是我不想每次都设置cookies，我该怎么办？这时候就有了新的武器——Session对象。
s = requests.Session()
s.get('http://httpbin.org/cookies/set ... %2339;)
r = s.get('http://httpbin.org/cookies')
3.4、使用代理
对于一些网站，在测试过程中多次请求后可以正常获取内容。但是一旦开始大规模爬取，对于大规模频繁的请求，网站可能会弹出验证码，或者跳转到登录认证页面，甚至直接屏蔽客户端IP，造成一定的周期的时间。内部无法访问。
import requests
proxies = {
"http" : "http://10.10.1.10:3128",
"https" : "http://10.10.1.10:1080",
}
requests.get("https://www.taobao.com", proxies=proxies)
4、动态渲染数据爬取
有时当我们抓取带有请求的页面时，结果可能与我们在浏览器中看到的不同：
在浏览器中可以看到页面数据正常显示，但是使用requests得到的结果却不是。这是因为请求都是原创的 HTML 文档，而浏览器中的页面是通过 JavaScript 处理数据的结果。这些数据有多种来源，可以通过 Ajax 加载或收录在 HTML 中。在文档中，也可能是由 JavaScript 和特定算法生成的。
对于第一种情况，数据加载是一种异步加载方式。最初的页面不会收录一些数据。原创页面加载完成后，会向服务器请求一个接口获取数据，然后再加载数据。处理并渲染到网页，其实就是发送一个ajax请求。
根据Web的发展趋势，这种形式的页面越来越多。网页的原创HTML文档不收录任何数据，数据通过Ajax统一加载后显示，这样在Web开发中可以分离前后端，以及服务器带来的压力减少直接渲染页面。
所以遇到这样的页面，直接使用requests等库抓取原创页面是无法获取有效数据的。这时候就需要分析网页后端向接口发送的Ajax请求了。如果可以使用requests来模拟ajax请求，那么就可以成功爬取了。
4.1、Ajax 定义
Ajax，全称是Asynchronous JavaScript and XML，即异步JavaScript XML，它不是一种编程语言，而是使用JavaScript与服务器交换数据，更新一些网页而不刷新页面和页面链接不变。技术。
对于一个传统的网页，如果要更新它的内容，就必须刷新整个页面，但是使用Ajax，你可以在不刷新整个页面的情况下更新页面的内容。在这个过程中，页面实际上是在后台与服务器交互的。获取到数据后，通过JavaScript来改变网页，从而更新网页的内容。
4.2、Ajax 数据抓取
向网页更新发送Ajax请求的过程可以分为以下几个步骤：
1、发送请求
2、解析内容
3、渲染网页
通过开发者模式找到类型为XHR的请求，查看请求的url和请求体，并进行模拟。
并非所有页面都可以通过分析 Ajax 进行爬取。有些页面的参数比较复杂，可能收录加密密钥。很难自己构造参数。
通过直接模拟浏览器操作，无需关注这些界面参数。
4.3、页面动态渲染
但是，javaScript 动态呈现的页面并不局限于 Ajax。有些网页的分页部分是由 JavaScript 生成的，而不是原创的 HTML 代码，不收录 Ajax 请求。比如ECharts的官方实例，它的图形都是JavaScript计算后生成的。
为了解决这些问题，我们可以直接使用模拟浏览器操作的方式，这样就可以看到浏览器里面有什么，抓取到什么源码，也就是什么时候可以抓取它是可见的。 这样，我们就不再需要关心网页内部的 JavaScript 使用什么算法来渲染页面，也不需要关心网页后台的 Ajax 接口的参数。 查看全部
scrapy分页抓取网页(2.3、Getamp常见的请求方法有两种(组图))
HTTPS 的安全基础是 SSL，所以通过它传输的内容是经过 SSL 加密的。它的主要功能可以分为两种。
2.3、获取并发布
有两种常见的请求方法：GET 和 POST。
直接在浏览器中输入URL回车，发起GET请求，请求的参数会直接收录在URL中。比如在百度搜索Python，这是一个GET请求，链接为/s?wd=Python，其中url收录请求的参数信息，其中参数wd代表要搜索的关键字。 GET 请求正文为空。 POST 请求主要是在提交表单时发出的。比如登录表单，输入用户名和密码后，点击“登录”按钮，一般会发起POST请求，数据一般以表单的形式传输，不体现在URL中。
GET 和 POST 请求方法有以下区别。
一般来说，登录时需要提交用户名和密码，其中收录敏感信息。如果使用 GET 方式请求，会在 URL 中暴露密码，导致密码泄露，所以最好通过 POST 发送。上传文件时，由于文件内容比较大，也使用POST方式。
2.4、爬虫定义
简单来说，爬虫是一个自动程序，它获取网页并提取和保存信息。
最关键的部分是构造一个请求并将其发送到服务器，然后接收并解析响应。
2.5、会话和 Cookie
HTTP的无状态意味着HTTP协议没有用于事务处理的内存能力，这意味着服务器不知道客户端处于什么状态。当我们向服务器发送请求时，服务器会解析请求，然后返回相应的响应。服务器负责完成这个过程，这个过程是完全独立的。服务器不会记录前后状态的变化，即缺少状态记录。这意味着如果前面的信息需要在后面进行处理，就必须重传，这就导致需要通过一些额外的前面的重复请求才能获得后续的响应，但是这样的效果显然不是我们想要的。为了保持前后的状态，千万不能把之前所有的请求都重传一次，这样太浪费资源了，对于这种需要用户登录的页面更是难上加难。
有两种技术可用于维护 HTTP 连接的状态，会话和 cookie。 session在服务端，即网站的服务端，用来保存用户的session信息；客户端的cookies也可以理解为浏览器端。使用 cookie，浏览器会自动将其附加到下一页访问。发送到服务器后，服务器通过识别Cookies来识别用户，进而判断用户是否处于登录状态，然后返回相应的响应。
我们可以理解，登录凭据存储在 cookie 中。有了它，您只需在下一次请求中发送带有cookies的请求，无需重新输入用户名、密码等信息再次登录。
2.5.1、常见误区
在谈论会话机制时会听到一个常见的误解 - “一旦关闭浏览器，会话就会消失”。想象一下会员卡的例子。除非顾客主动要求店家注销卡，否则店家绝不会轻易删除顾客的资料。会话也是如此，除非程序告诉服务器删除会话，否则服务器会保留它。比如我们在进行注销操作时，程序一般会删除会话。
但是当我们关闭浏览器时，浏览器并没有在关闭前主动通知服务器即将关闭，所以服务器根本没有机会知道浏览器已经关闭。产生这种错觉的原因是大部分会话机制使用会话cookie来保存会话ID信息，而cookie在关闭浏览器后消失。再次连接服务器时，找不到原来的会话。如果服务器设置的cookies保存到硬盘，或者浏览器发送的HTTP请求头通过某种方式被改写，将原来的cookies发送给服务器，那么可以再次打开浏览器，原来的会话ID仍然可以找到，仍然可以维护。登录状态。
而正是因为关闭浏览器不会导致会话被删除，这就需要服务器为会话设置一个过期时间。当自客户端上次使用会话以来的时间超过此过期时间时，服务器可以考虑在活动停止时删除客户端会话以节省存储空间。
3、基本操作
# 普通 GET 请求
response = urllib.request.urlopen('https://www.python.org')
print(response.read().decode('utf-8'))
# POST 请求
# 这里我们传递了一个参数 word, 值是 hello, 它需要被转码成 bytes（字节流）类型
# 而转字节流采用了 bytes 方法，该方法的第一个参数需要是 str（字符串）类型
data = bytes(urllib.parse.urlencode({'word' : 'hello'}), encoding ＝ 'utf8')
# 还有 timeout 设置超时参数
# cafile 和 capath 这两个参数分别指定 CA 证书和它的路径
response = urllib.request.urlopen('http://httpbin.org/post', data = data)
# request 更多的控制参数
# headers 参数通常是设置 User-Agent 来伪装浏览器
# method 代表 GET、POST 等
urllib.request.Request(url, data=None, headers={}, origin_req_host=None, unverifiable=False, method=None)
3.1、高级操作
# urllib.request 模块里的 BaseHandler 类可以处理 Cookies 等高级操作
# 比如下图的需要身份验证
from urllib.request import HTTPPasswordMgrWithDefaultRealm, HTTPBasicAuthHandler, build_opener
from urllib.error import URLError
username = username
password = 'password'
url = 'http://localhost:5000/'
p = HTTPPasswordMgrWithDefaultRealm()
p.add_password(None, url, username, password)
auth_handler = HTTPBasicAuthHandler(p)
opener = build_opener(auth_handler)
try:
result = opener.open(url)
html = result.read().decode('utf8')
print(html)
except URLError as e:
print(e.reason)
# 设置代理
proxy_handler = ProxyHandler({
'http' : 'http://127.0.0.1:9743',
'https': 'https://127.0.0.1:9743'
})
opener = build_opener(proxy_handler)
# 设置 Cookies
cookie = http.cookiejar.CookieJar()
handler = urllib.request.HTTPCookieProcessor(cookie)
opener = urllib.request.build_opener(handler)
response = opener.open('http://www.baidu.com')
# request 库设置 Cookies，request 库可以直接把 Cookie 参数放到 headers 里
r = requests.get('https://www.baidu.com')
# 从中可以看出 Cookie 的类型
print(r.cookies)
for key, value in r.cookies.items():
print(key + '=' + value)
# urlparse() 可以实现 URL 的识别和分段
# quote() 可以将中文字符串转化为 URL 编码
# 对应 unquote() 就是反过来
# 身份验证
r = requests.get('http://localhost:5000', auth＝('username', 'password'))
3.1.1、处理二进制数据
# 下载文件
import requests
r = requests.get('https://github.com/favicon.ic'）
with open('favicon.ico', 'wb') as f:
f.write(r.content)
# 上传文件
files = {'file' : open('favicon.ico', 'rb')}
r = requests.post('http://httpbin.org/post', files=files)
3.2、机器人协议
Robots 协议也称为爬虫协议和机器人协议。它的全称是Robots Exclusion Protocol，用于告诉爬虫和搜索引擎哪些页面可以爬取，哪些页面不能爬取。它通常是一个名为 robots.txt 的文本文件，通常放在 网站 的根目录下。
搜索爬虫访问网站时，首先会检查网站根目录下是否有robots.txt文件。如果存在，搜索爬虫将根据其中定义的爬取范围进行爬取。如果没有找到该文件，搜索爬虫将访问所有可直接访问的页面。
User-agent: *
Disallow: /
Allow: /public/
上述案例的文件内容表示所有搜索爬虫只允许爬取公共目录。
User-agent用于设置爬虫的名称，*表示适用于所有。
disallow代表不能爬取的目录，/代表禁止爬取所有页面。
# 传入 robots.txt 文件的链接即可解析
urllib.robotparser.RobotFileParser(url='')
print(rp.can_fetch('*', 'http://www.jianshu.com/p/b67554025d7d'))
3.3、会话维护
在请求中，如果直接使用get或post等方法，确实可以模拟网页请求，但这实际上相当于不同的会话，也就是说你使用两个浏览器打开不同的页面。
想象这样一个场景，第一次请求使用post方法登录某个网站，第二次登录成功后想获取自己的个人信息，再次使用get方法请求个人信息页面。其实这相当于打开了两个浏览器，两个完全不相关的会话。能否成功获取个人信息？当然不是。
你们中的一些人可能说过我可以为两个请求设置相同的 cookie，对吧？是的，但是这样做很麻烦，而且我们有一个更简单的解决方案。
其实这个问题的主要解决方案是保持同一个会话，相当于打开一个新的浏览器标签而不是打开一个新的浏览器。但是我不想每次都设置cookies，我该怎么办？这时候就有了新的武器——Session对象。
s = requests.Session()
s.get('http://httpbin.org/cookies/set ... %2339;)
r = s.get('http://httpbin.org/cookies')
3.4、使用代理
对于一些网站，在测试过程中多次请求后可以正常获取内容。但是一旦开始大规模爬取，对于大规模频繁的请求，网站可能会弹出验证码，或者跳转到登录认证页面，甚至直接屏蔽客户端IP，造成一定的周期的时间。内部无法访问。
import requests
proxies = {
"http" : "http://10.10.1.10:3128",
"https" : "http://10.10.1.10:1080",
}
requests.get("https://www.taobao.com", proxies=proxies)
4、动态渲染数据爬取
有时当我们抓取带有请求的页面时，结果可能与我们在浏览器中看到的不同：
在浏览器中可以看到页面数据正常显示，但是使用requests得到的结果却不是。这是因为请求都是原创的 HTML 文档，而浏览器中的页面是通过 JavaScript 处理数据的结果。这些数据有多种来源，可以通过 Ajax 加载或收录在 HTML 中。在文档中，也可能是由 JavaScript 和特定算法生成的。
对于第一种情况，数据加载是一种异步加载方式。最初的页面不会收录一些数据。原创页面加载完成后，会向服务器请求一个接口获取数据，然后再加载数据。处理并渲染到网页，其实就是发送一个ajax请求。
根据Web的发展趋势，这种形式的页面越来越多。网页的原创HTML文档不收录任何数据，数据通过Ajax统一加载后显示，这样在Web开发中可以分离前后端，以及服务器带来的压力减少直接渲染页面。
所以遇到这样的页面，直接使用requests等库抓取原创页面是无法获取有效数据的。这时候就需要分析网页后端向接口发送的Ajax请求了。如果可以使用requests来模拟ajax请求，那么就可以成功爬取了。
4.1、Ajax 定义
Ajax，全称是Asynchronous JavaScript and XML，即异步JavaScript XML，它不是一种编程语言，而是使用JavaScript与服务器交换数据，更新一些网页而不刷新页面和页面链接不变。技术。
对于一个传统的网页，如果要更新它的内容，就必须刷新整个页面，但是使用Ajax，你可以在不刷新整个页面的情况下更新页面的内容。在这个过程中，页面实际上是在后台与服务器交互的。获取到数据后，通过JavaScript来改变网页，从而更新网页的内容。
4.2、Ajax 数据抓取
向网页更新发送Ajax请求的过程可以分为以下几个步骤：
1、发送请求
2、解析内容
3、渲染网页
通过开发者模式找到类型为XHR的请求，查看请求的url和请求体，并进行模拟。
并非所有页面都可以通过分析 Ajax 进行爬取。有些页面的参数比较复杂，可能收录加密密钥。很难自己构造参数。
通过直接模拟浏览器操作，无需关注这些界面参数。
4.3、页面动态渲染
但是，javaScript 动态呈现的页面并不局限于 Ajax。有些网页的分页部分是由 JavaScript 生成的，而不是原创的 HTML 代码，不收录 Ajax 请求。比如ECharts的官方实例，它的图形都是JavaScript计算后生成的。
为了解决这些问题，我们可以直接使用模拟浏览器操作的方式，这样就可以看到浏览器里面有什么，抓取到什么源码，也就是什么时候可以抓取它是可见的。 这样，我们就不再需要关心网页内部的 JavaScript 使用什么算法来渲染页面，也不需要关心网页后台的 Ajax 接口的参数。
scrapy分页抓取网页(环境搭建window系统环境安装AnacondaAnaconda文章目录解析篇)
网站优化 • 优采云 发表了文章 • 0 个评论 • 54 次浏览 • 2022-02-18 09:04
scrapy分页抓取网页(环境搭建window系统环境安装AnacondaAnaconda文章目录解析篇)
介绍
开发环境为 Python3.6, Scrapy 版本2.4.x , Gerapy 版本0.9.x , 所有爬虫项目的index目录
本系列内容作为规范爬虫的指南，为广大爬虫工程师分享爬虫工作经验，用作者自己的经验了解Python3的爬虫工作心得。
Environment 搭建window系统环境
安装 Anaconda
Anaconda 指的是一个开源的 Python 发行版，其中收录 N 多个科学包，例如 Python 和 conda 及其依赖项。简单理解为傻瓜的python包。
蟒蛇下载地址
由于笔者买不起Apple系列电脑，这里以win系统安装为例（Linux必须是图形界面的操作系统，如Ubuntu系统）
打开安装程序后，继续单击下一步。
安装结束，点击关闭，然后打开命令行CMD，出现下图证明安装成功。
安装 Pycharm
社区版 & 专业版 Pycharm 下载地址
下载后根据自己的情况选择压缩包。
在如图所示的位置启动程序。
安装 Scrapy
pip install scrapy==2.4.0
Linux系统环境
以腾讯云的 Centos 7.x 版本为例。其他版本的系统略有不同。如果您有任何安装问题，您可以留言。
Python3安装
'''安装必备包'''
yum groupinstall 'Development Tools'
yum install -y ncurses-libs zlib-devel mysql-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel
yum -y install gcc
'''下载python3.6.5'''
cd /usr/local/
wget https://www.python.org/ftp/pyt ... ar.xz
'''解压'''
tar -xf Python-3.6.5.tar.xz
mkdir python3
mv Python-3.6.5 python3
cd python3/Python-3.6.5
./configure --prefix=/usr/local/python3 --enable-optimizations
make
make altinstall
'''修改软连接'''
ln -s /usr/local/python3/bin/python3.6 /usr/bin/python3
ln -s /usr/local/python3/bin/pip3.6 /usr/bin/pip3
'''删除软连接,如果设置软连接出错使用'''
rm -rf /usr/bin/python3
rm -rf /usr/bin/pip3
'''检查是否安装版本正确'''
python3 --version
安装 Scrapy
pip3 install scrapy==2.4.0
Scrapy爬虫框架
Scrapy，一个用 Python 开发的快速、高级的屏幕抓取和网页抓取框架，用于抓取网站并从页面中提取结构化数据。Scrapy 用途广泛，可用于数据挖掘、监控和自动化测试。
它最初是为页面抓取（更准确地说是网页抓取）而设计的，后台也用于获取API或一般网络爬虫返回的数据。
要了解学习所有 Scrapy 模块，请点击传送门
[scrapy 2.4.0 文章目录]源码分析：所有配置目录索引
数据采集流程概览
调度器：假设它是一个 URL 的优先队列（爬取网页的网站或链接），让它决定下一个要爬取的 URL，同时去除重复的 URL（不做无用的工作）。用户可以根据自己的需要自定义调度器。
下载器（Downloader）：所有组件中最繁重的，它用于在网络上高速下载资源。Scrapy 的下载器代码并不太复杂，但是效率很高。主要原因是Scrapy下载器是建立在twisted的高效异步模型之上的（其实整个框架都是建立在这个模型之上的）。
爬虫（Spider）：用户定制自己的爬虫（通过自定义正则表达式等语法），从特定的网页中提取自己需要的信息，即所谓的实体（Item）。用户还可以从中提取链接，让 Scrapy 继续爬取下一页。
项目管道：用于处理蜘蛛提取的实体。主要功能是持久化实体，验证实体的有效性，清除不必要的信息。
Scrapy引擎（Scrapy Engine）：Scrapy引擎是整个框架的核心。它用于控制调试器、下载器和爬虫。实际上，引擎相当于计算机的CPU，它控制着整个过程。 查看全部
介绍
开发环境为 Python3.6, Scrapy 版本2.4.x , Gerapy 版本0.9.x , 所有爬虫项目的index目录
本系列内容作为规范爬虫的指南，为广大爬虫工程师分享爬虫工作经验，用作者自己的经验了解Python3的爬虫工作心得。
Environment 搭建window系统环境
安装 Anaconda
Anaconda 指的是一个开源的 Python 发行版，其中收录 N 多个科学包，例如 Python 和 conda 及其依赖项。简单理解为傻瓜的python包。
蟒蛇下载地址
由于笔者买不起Apple系列电脑，这里以win系统安装为例（Linux必须是图形界面的操作系统，如Ubuntu系统）
打开安装程序后，继续单击下一步。
安装结束，点击关闭，然后打开命令行CMD，出现下图证明安装成功。
安装 Pycharm
社区版 & 专业版 Pycharm 下载地址
下载后根据自己的情况选择压缩包。
在如图所示的位置启动程序。
安装 Scrapy
pip install scrapy==2.4.0
Linux系统环境
以腾讯云的 Centos 7.x 版本为例。其他版本的系统略有不同。如果您有任何安装问题，您可以留言。
Python3安装
'''安装必备包'''
yum groupinstall 'Development Tools'
yum install -y ncurses-libs zlib-devel mysql-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel
yum -y install gcc
'''下载python3.6.5'''
cd /usr/local/
wget https://www.python.org/ftp/pyt ... ar.xz
'''解压'''
tar -xf Python-3.6.5.tar.xz
mkdir python3
mv Python-3.6.5 python3
cd python3/Python-3.6.5
./configure --prefix=/usr/local/python3 --enable-optimizations
make
make altinstall
'''修改软连接'''
ln -s /usr/local/python3/bin/python3.6 /usr/bin/python3
ln -s /usr/local/python3/bin/pip3.6 /usr/bin/pip3
'''删除软连接,如果设置软连接出错使用'''
rm -rf /usr/bin/python3
rm -rf /usr/bin/pip3
'''检查是否安装版本正确'''
python3 --version
安装 Scrapy
pip3 install scrapy==2.4.0
Scrapy爬虫框架
Scrapy，一个用 Python 开发的快速、高级的屏幕抓取和网页抓取框架，用于抓取网站并从页面中提取结构化数据。Scrapy 用途广泛，可用于数据挖掘、监控和自动化测试。
它最初是为页面抓取（更准确地说是网页抓取）而设计的，后台也用于获取API或一般网络爬虫返回的数据。
要了解学习所有 Scrapy 模块，请点击传送门
[scrapy 2.4.0 文章目录]源码分析：所有配置目录索引
数据采集流程概览
调度器：假设它是一个 URL 的优先队列（爬取网页的网站或链接），让它决定下一个要爬取的 URL，同时去除重复的 URL（不做无用的工作）。用户可以根据自己的需要自定义调度器。
下载器（Downloader）：所有组件中最繁重的，它用于在网络上高速下载资源。Scrapy 的下载器代码并不太复杂，但是效率很高。主要原因是Scrapy下载器是建立在twisted的高效异步模型之上的（其实整个框架都是建立在这个模型之上的）。
爬虫（Spider）：用户定制自己的爬虫（通过自定义正则表达式等语法），从特定的网页中提取自己需要的信息，即所谓的实体（Item）。用户还可以从中提取链接，让 Scrapy 继续爬取下一页。
项目管道：用于处理蜘蛛提取的实体。主要功能是持久化实体，验证实体的有效性，清除不必要的信息。
Scrapy引擎（Scrapy Engine）：Scrapy引擎是整个框架的核心。它用于控制调试器、下载器和爬虫。实际上，引擎相当于计算机的CPU，它控制着整个过程。 查看全部
scrapy分页抓取网页(环境搭建window系统环境安装AnacondaAnaconda文章目录解析篇)
介绍
开发环境为 Python3.6, Scrapy 版本2.4.x , Gerapy 版本0.9.x , 所有爬虫项目的index目录
本系列内容作为规范爬虫的指南，为广大爬虫工程师分享爬虫工作经验，用作者自己的经验了解Python3的爬虫工作心得。
Environment 搭建window系统环境
安装 Anaconda
Anaconda 指的是一个开源的 Python 发行版，其中收录 N 多个科学包，例如 Python 和 conda 及其依赖项。简单理解为傻瓜的python包。
蟒蛇下载地址
由于笔者买不起Apple系列电脑，这里以win系统安装为例（Linux必须是图形界面的操作系统，如Ubuntu系统）
打开安装程序后，继续单击下一步。
安装结束，点击关闭，然后打开命令行CMD，出现下图证明安装成功。
安装 Pycharm
社区版 & 专业版 Pycharm 下载地址
下载后根据自己的情况选择压缩包。
在如图所示的位置启动程序。
安装 Scrapy
pip install scrapy==2.4.0
Linux系统环境
以腾讯云的 Centos 7.x 版本为例。其他版本的系统略有不同。如果您有任何安装问题，您可以留言。
Python3安装
'''安装必备包'''
yum groupinstall 'Development Tools'
yum install -y ncurses-libs zlib-devel mysql-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel
yum -y install gcc
'''下载python3.6.5'''
cd /usr/local/
wget https://www.python.org/ftp/pyt ... ar.xz
'''解压'''
tar -xf Python-3.6.5.tar.xz
mkdir python3
mv Python-3.6.5 python3
cd python3/Python-3.6.5
./configure --prefix=/usr/local/python3 --enable-optimizations
make
make altinstall
'''修改软连接'''
ln -s /usr/local/python3/bin/python3.6 /usr/bin/python3
ln -s /usr/local/python3/bin/pip3.6 /usr/bin/pip3
'''删除软连接,如果设置软连接出错使用'''
rm -rf /usr/bin/python3
rm -rf /usr/bin/pip3
'''检查是否安装版本正确'''
python3 --version
安装 Scrapy
pip3 install scrapy==2.4.0
Scrapy爬虫框架
Scrapy，一个用 Python 开发的快速、高级的屏幕抓取和网页抓取框架，用于抓取网站并从页面中提取结构化数据。Scrapy 用途广泛，可用于数据挖掘、监控和自动化测试。
它最初是为页面抓取（更准确地说是网页抓取）而设计的，后台也用于获取API或一般网络爬虫返回的数据。
要了解学习所有 Scrapy 模块，请点击传送门
[scrapy 2.4.0 文章目录]源码分析：所有配置目录索引
数据采集流程概览
调度器：假设它是一个 URL 的优先队列（爬取网页的网站或链接），让它决定下一个要爬取的 URL，同时去除重复的 URL（不做无用的工作）。用户可以根据自己的需要自定义调度器。
下载器（Downloader）：所有组件中最繁重的，它用于在网络上高速下载资源。Scrapy 的下载器代码并不太复杂，但是效率很高。主要原因是Scrapy下载器是建立在twisted的高效异步模型之上的（其实整个框架都是建立在这个模型之上的）。
爬虫（Spider）：用户定制自己的爬虫（通过自定义正则表达式等语法），从特定的网页中提取自己需要的信息，即所谓的实体（Item）。用户还可以从中提取链接，让 Scrapy 继续爬取下一页。
项目管道：用于处理蜘蛛提取的实体。主要功能是持久化实体，验证实体的有效性，清除不必要的信息。
Scrapy引擎（Scrapy Engine）：Scrapy引擎是整个框架的核心。它用于控制调试器、下载器和爬虫。实际上，引擎相当于计算机的CPU，它控制着整个过程。
scrapy分页抓取网页(如何在scrapy爬虫框架中创建网页节点-scrapy框架初体验)
网站优化 • 优采云 发表了文章 • 0 个评论 • 65 次浏览 • 2022-02-18 05:03
scrapy分页抓取网页(如何在scrapy爬虫框架中创建网页节点-scrapy框架初体验)
scrapy分页抓取网页节点发现自己要抓取的json序列化数据-scrapy。models。request利用python爬虫框架：python3。6参考文章：如何在scrapy爬虫框架中创建网页节点-scrapy爬虫框架初体验scrapypython爬虫框架初体验-用一条命令抓取一页信息请求对应链接-用一条命令抓取一页信息读取对应链接并分页。
如果是在excel中导入爬虫数据的话，需要excel转html，然后导入scrapy。
excel>data.txt>text
如果只是放一行的话，html是有文本格式，把文本格式的txt中保存为scrapy里的变量就行。
fromscrapy。fieldimportfieldfield(writer='field')localwriter_obj=[xforxinfield(writer_obj)]。valueifxinscrapy。field。value:returnxfield(writer='item')data=field(forfieldindata)data。replace('item','itemgroup')。
scrapy-request
用java做爬虫？那样找一个本地的页面文件，然后存下来。我刚学scrapy用python爬取，然后把那个页面存到一个json文件。
做成html文件
到excel里查找
如果你本地已经存有spiders的话，去找你要爬取的spider，ctrl+r它就有个excelxml的文件，如果没有， 查看全部
scrapy分页抓取网页节点发现自己要抓取的json序列化数据-scrapy。models。request利用python爬虫框架：python3。6参考文章：如何在scrapy爬虫框架中创建网页节点-scrapy爬虫框架初体验scrapypython爬虫框架初体验-用一条命令抓取一页信息请求对应链接-用一条命令抓取一页信息读取对应链接并分页。
如果是在excel中导入爬虫数据的话，需要excel转html，然后导入scrapy。
excel>data.txt>text
如果只是放一行的话，html是有文本格式，把文本格式的txt中保存为scrapy里的变量就行。
fromscrapy。fieldimportfieldfield(writer='field')localwriter_obj=[xforxinfield(writer_obj)]。valueifxinscrapy。field。value:returnxfield(writer='item')data=field(forfieldindata)data。replace('item','itemgroup')。
scrapy-request
用java做爬虫？那样找一个本地的页面文件，然后存下来。我刚学scrapy用python爬取，然后把那个页面存到一个json文件。
做成html文件
到excel里查找
如果你本地已经存有spiders的话，去找你要爬取的spider，ctrl+r它就有个excelxml的文件，如果没有， 查看全部
scrapy分页抓取网页(如何在scrapy爬虫框架中创建网页节点-scrapy框架初体验)
scrapy分页抓取网页节点发现自己要抓取的json序列化数据-scrapy。models。request利用python爬虫框架：python3。6参考文章：如何在scrapy爬虫框架中创建网页节点-scrapy爬虫框架初体验scrapypython爬虫框架初体验-用一条命令抓取一页信息请求对应链接-用一条命令抓取一页信息读取对应链接并分页。
如果是在excel中导入爬虫数据的话，需要excel转html，然后导入scrapy。
excel>data.txt>text
如果只是放一行的话，html是有文本格式，把文本格式的txt中保存为scrapy里的变量就行。
fromscrapy。fieldimportfieldfield(writer='field')localwriter_obj=[xforxinfield(writer_obj)]。valueifxinscrapy。field。value:returnxfield(writer='item')data=field(forfieldindata)data。replace('item','itemgroup')。
scrapy-request
用java做爬虫？那样找一个本地的页面文件，然后存下来。我刚学scrapy用python爬取，然后把那个页面存到一个json文件。
做成html文件
到excel里查找
如果你本地已经存有spiders的话，去找你要爬取的spider，ctrl+r它就有个excelxml的文件，如果没有，
scrapy分页抓取网页(scrapy表达式先用python3天：干货教程|爬虫一小时系列教程)
网站优化 • 优采云 发表了文章 • 0 个评论 • 62 次浏览 • 2022-02-17 11:01
scrapy分页抓取网页(scrapy表达式先用python3天：干货教程|爬虫一小时系列教程)
scrapy分页抓取网页我们的爬虫需要发起多次请求，并从每一次请求中获取数据，而这样就导致不方便爬取分页页面。在capy中把整个爬虫分为多个子爬虫。pipinstallgenscrapy安装完genscrapy后再次pipinstallscrapy==2.3.1我们可以这样写爬虫scrapygenscrapygenscrapy=genscrapy.spider(spider_name='org.doubanmara_demo',start_urls=spider_name,spider_end_urls=spider_end_urls,state=spider_state,url_pattern='/',allowed_headers={'x-requested-with':'xmlhttprequest'})1，抓取第一页爬取整个项目3，爬取最后一页。
转化为正则表达式
先用python爬虫3天：干货教程|爬虫一小时系列教程-allc/_第二步：将数据分析分割成两个目录：/vendor/id/temp.xml文件和/vendor/id/list.xml文件，其中/vendor/id/temp.xml文件中抓取的数据写入request对象中，/vendor/id/list.xml中的数据写入list对象中。
直接用scrapy是http请求出来的数据.分页与否要看具体模块和具体实现
googlenextstep/scrapy，第二步就分页了。
scrapy3
直接返回/vendor/id/temp.xmlvia第二页到/vendor/id/list.xml 查看全部
scrapy分页抓取网页我们的爬虫需要发起多次请求，并从每一次请求中获取数据，而这样就导致不方便爬取分页页面。在capy中把整个爬虫分为多个子爬虫。pipinstallgenscrapy安装完genscrapy后再次pipinstallscrapy==2.3.1我们可以这样写爬虫scrapygenscrapygenscrapy=genscrapy.spider(spider_name='org.doubanmara_demo',start_urls=spider_name,spider_end_urls=spider_end_urls,state=spider_state,url_pattern='/',allowed_headers={'x-requested-with':'xmlhttprequest'})1，抓取第一页爬取整个项目3，爬取最后一页。
转化为正则表达式
先用python爬虫3天：干货教程|爬虫一小时系列教程-allc/_第二步：将数据分析分割成两个目录：/vendor/id/temp.xml文件和/vendor/id/list.xml文件，其中/vendor/id/temp.xml文件中抓取的数据写入request对象中，/vendor/id/list.xml中的数据写入list对象中。
直接用scrapy是http请求出来的数据.分页与否要看具体模块和具体实现
googlenextstep/scrapy，第二步就分页了。
scrapy3
直接返回/vendor/id/temp.xmlvia第二页到/vendor/id/list.xml 查看全部
scrapy分页抓取网页(scrapy表达式先用python3天：干货教程|爬虫一小时系列教程)
scrapy分页抓取网页我们的爬虫需要发起多次请求，并从每一次请求中获取数据，而这样就导致不方便爬取分页页面。在capy中把整个爬虫分为多个子爬虫。pipinstallgenscrapy安装完genscrapy后再次pipinstallscrapy==2.3.1我们可以这样写爬虫scrapygenscrapygenscrapy=genscrapy.spider(spider_name='org.doubanmara_demo',start_urls=spider_name,spider_end_urls=spider_end_urls,state=spider_state,url_pattern='/',allowed_headers={'x-requested-with':'xmlhttprequest'})1，抓取第一页爬取整个项目3，爬取最后一页。
转化为正则表达式
先用python爬虫3天：干货教程|爬虫一小时系列教程-allc/_第二步：将数据分析分割成两个目录：/vendor/id/temp.xml文件和/vendor/id/list.xml文件，其中/vendor/id/temp.xml文件中抓取的数据写入request对象中，/vendor/id/list.xml中的数据写入list对象中。
直接用scrapy是http请求出来的数据.分页与否要看具体模块和具体实现
googlenextstep/scrapy，第二步就分页了。
scrapy3
直接返回/vendor/id/temp.xmlvia第二页到/vendor/id/list.xml
scrapy分页抓取网页( 一个新网站如何让搜索引擎快速收录?下面西营门小程序)
网站优化 • 优采云 发表了文章 • 0 个评论 • 79 次浏览 • 2022-02-16 17:23
scrapy分页抓取网页(
一个新网站如何让搜索引擎快速收录?下面西营门小程序)
一个新的网站如何让搜索引擎变快收录？下面，盛汇友联就为大家讲解一下如何解决这个问题。
1、网站结构应该便于搜索引擎蜘蛛阅读
目前，搜索引擎蜘蛛只能很好地处理文本内容，而不能读取非文本内容，如Flash、图片等，所以我们应该尽量在文本内容中表达更重要的内容。例如 网站 的导航栏必须使用文本类型的链接。如果使用Flash和图片，可能看起来更漂亮，但对SEO不友好。而对于 网站 用户来说，图片和 Flash 的加载速度很慢。
2、优化网页标记
主要包括页面标题（Title）优化、关键词（关键字）优化和描述（Description）等基本信息。
3、将您自己的网站网址添加到主要搜索引擎
<p>在制作新的网站时，一直希望能尽快被搜索引擎收录，网站被 查看全部
一个新网站如何让搜索引擎快速收录?下面西营门小程序)
一个新的网站如何让搜索引擎变快收录？下面，盛汇友联就为大家讲解一下如何解决这个问题。
1、网站结构应该便于搜索引擎蜘蛛阅读
目前，搜索引擎蜘蛛只能很好地处理文本内容，而不能读取非文本内容，如Flash、图片等，所以我们应该尽量在文本内容中表达更重要的内容。例如 网站 的导航栏必须使用文本类型的链接。如果使用Flash和图片，可能看起来更漂亮，但对SEO不友好。而对于 网站 用户来说，图片和 Flash 的加载速度很慢。
2、优化网页标记
主要包括页面标题（Title）优化、关键词（关键字）优化和描述（Description）等基本信息。
3、将您自己的网站网址添加到主要搜索引擎
<p>在制作新的网站时，一直希望能尽快被搜索引擎收录，网站被 查看全部
scrapy分页抓取网页(
一个新网站如何让搜索引擎快速收录?下面西营门小程序)
一个新的网站如何让搜索引擎变快收录？下面，盛汇友联就为大家讲解一下如何解决这个问题。
1、网站结构应该便于搜索引擎蜘蛛阅读
目前，搜索引擎蜘蛛只能很好地处理文本内容，而不能读取非文本内容，如Flash、图片等，所以我们应该尽量在文本内容中表达更重要的内容。例如 网站 的导航栏必须使用文本类型的链接。如果使用Flash和图片，可能看起来更漂亮，但对SEO不友好。而对于 网站 用户来说，图片和 Flash 的加载速度很慢。
2、优化网页标记
主要包括页面标题（Title）优化、关键词（关键字）优化和描述（Description）等基本信息。
3、将您自己的网站网址添加到主要搜索引擎
<p>在制作新的网站时，一直希望能尽快被搜索引擎收录，网站被
scrapy分页抓取网页(如何抓取目标网站是以Js的方式动态生成数据的网页)
网站优化 • 优采云 发表了文章 • 0 个评论 • 46 次浏览 • 2022-02-12 04:21
scrapy分页抓取网页(如何抓取目标网站是以Js的方式动态生成数据的网页)
我们在爬取数据的时候，如果目标网站是以Js的方式动态生成数据，以滚动页面的方式进行分页，那我们怎么爬取呢？
如今日头条网站：
我们可以使用 Selenium 来做到这一点。虽然 Selenium 是为 Web 应用程序的自动化测试而设计的，但它非常适合数据抓取，可以轻松绕过 网站 的反爬虫限制，因为 Selenium 直接运行在浏览器中，就像真正的用户一样它。
使用Selenium，我们不仅可以爬取Js动态生成数据的网页，还可以爬取通过滚动页面进行分页的网页。
首先，我们使用maven来导入Selenium依赖：
org.seleniumhq.selenium
selenium-java
2.47.1
然后就可以编写代码进行爬取了：
<p>import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import java.util.List;
import java.util.Random;
/**
* 如何抓取Js动态生成数据且以滚动页面方式分页的网页
* 以抓取今日头条为例说明：http://toutiao.com/
* Created by ysc on 10/13/15.
*/
public class Toutiao {
public static void main(String[] args) throws Exception{
//等待数据加载的时间
//为了防止服务器封锁，这里的时间要模拟人的行为，随机且不能太短
long waitLoadBaseTime = 3000;
int waitLoadRandomTime = 3000;
Random random = new Random(System.currentTimeMillis());
//火狐浏览器
WebDriver driver = new FirefoxDriver();
//要抓取的网页
driver.get("http://toutiao.com/");
//等待页面动态加载完毕
Thread.sleep(waitLoadBaseTime+random.nextInt(waitLoadRandomTime));
//要加载多少页数据
int pages=5;
for(int i=0; i 查看全部
我们在爬取数据的时候，如果目标网站是以Js的方式动态生成数据，以滚动页面的方式进行分页，那我们怎么爬取呢？
如今日头条网站：
我们可以使用 Selenium 来做到这一点。虽然 Selenium 是为 Web 应用程序的自动化测试而设计的，但它非常适合数据抓取，可以轻松绕过 网站 的反爬虫限制，因为 Selenium 直接运行在浏览器中，就像真正的用户一样它。
使用Selenium，我们不仅可以爬取Js动态生成数据的网页，还可以爬取通过滚动页面进行分页的网页。
首先，我们使用maven来导入Selenium依赖：
org.seleniumhq.selenium
selenium-java
2.47.1
然后就可以编写代码进行爬取了：
<p>import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import java.util.List;
import java.util.Random;
/**
* 如何抓取Js动态生成数据且以滚动页面方式分页的网页
* 以抓取今日头条为例说明：http://toutiao.com/
* Created by ysc on 10/13/15.
*/
public class Toutiao {
public static void main(String[] args) throws Exception{
//等待数据加载的时间
//为了防止服务器封锁，这里的时间要模拟人的行为，随机且不能太短
long waitLoadBaseTime = 3000;
int waitLoadRandomTime = 3000;
Random random = new Random(System.currentTimeMillis());
//火狐浏览器
WebDriver driver = new FirefoxDriver();
//要抓取的网页
driver.get("http://toutiao.com/");
//等待页面动态加载完毕
Thread.sleep(waitLoadBaseTime+random.nextInt(waitLoadRandomTime));
//要加载多少页数据
int pages=5;
for(int i=0; i 查看全部
scrapy分页抓取网页(如何抓取目标网站是以Js的方式动态生成数据的网页)
我们在爬取数据的时候，如果目标网站是以Js的方式动态生成数据，以滚动页面的方式进行分页，那我们怎么爬取呢？
如今日头条网站：
我们可以使用 Selenium 来做到这一点。虽然 Selenium 是为 Web 应用程序的自动化测试而设计的，但它非常适合数据抓取，可以轻松绕过 网站 的反爬虫限制，因为 Selenium 直接运行在浏览器中，就像真正的用户一样它。
使用Selenium，我们不仅可以爬取Js动态生成数据的网页，还可以爬取通过滚动页面进行分页的网页。
首先，我们使用maven来导入Selenium依赖：
org.seleniumhq.selenium
selenium-java
2.47.1
然后就可以编写代码进行爬取了：
<p>import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import java.util.List;
import java.util.Random;
/**
* 如何抓取Js动态生成数据且以滚动页面方式分页的网页
* 以抓取今日头条为例说明：http://toutiao.com/
* Created by ysc on 10/13/15.
*/
public class Toutiao {
public static void main(String[] args) throws Exception{
//等待数据加载的时间
//为了防止服务器封锁，这里的时间要模拟人的行为，随机且不能太短
long waitLoadBaseTime = 3000;
int waitLoadRandomTime = 3000;
Random random = new Random(System.currentTimeMillis());
//火狐浏览器
WebDriver driver = new FirefoxDriver();
//要抓取的网页
driver.get("http://toutiao.com/";);
//等待页面动态加载完毕
Thread.sleep(waitLoadBaseTime+random.nextInt(waitLoadRandomTime));
//要加载多少页数据
int pages=5;
for(int i=0; i
scrapy分页抓取网页(scrapy分页抓取网页信息实现网络爬虫和抓包分析器-scrapy)
网站优化 • 优采云 发表了文章 • 0 个评论 • 69 次浏览 • 2022-02-11 11:02
scrapy分页抓取网页(scrapy分页抓取网页信息实现网络爬虫和抓包分析器-scrapy)
scrapy分页抓取网页信息实现网络爬虫和抓包分析器-scrapy中文文档-csdn博客-中国最大的it技术社区scrapy是一个开源的pythonweb框架，它提供了一个功能强大的networkapi，可以让爬虫获取网络网页信息和重定向网页从而爬取动态网页。scrapy的核心是用于在scrapyweb框架中创建和利用多线程抓取和分析网页的核心功能。
scrapy通过分层的scrapyweb框架将请求或响应流传递给下游爬虫/job可以进行不同的数据抓取。scrapy支持windows、linux和mac系统。我们分别在mac和windows系统环境下做演示。scrapy分页抓取网页信息实现代码：importscrapyclassglobaljsonitem:name=scrapy.field(scrapy.field())aspnum=scrapy.field(scrapy.field())url=''headers={'user-agent':'mozilla/5.0(windowsnt10.0;win64;x64)applewebkit/537.36(khtml,likegecko)chrome/72.0.3440.137safari/537.36'}referer=scrapy.get(headers=headers)scrapy.request(url=url,post=globaljsonitem,headers=headers)scrapy.items().urlparameter('url',list(request.text))fig=plt.figure()a=fig.add_subplot(2,2,1)name=globaljsonitem(a)aspnum=globaljsonitem(a)url=''url=''partial=globaljsonitem(aspnum)url='"\s+"\s+"\s+"\s+"+"\s+"\s+"\s+"+"\s+"\s+"+"\s+"'content=scrapy.extract_text(url,encoding='utf-8')withopen('test.txt','w+')asfp:fp.write(content)请求进入到后台，content.follow('/')，可以看到，此时请求是从创建爬虫的giteawall.py文件开始抓取下来的，爬虫之后，就可以去掉设置参数/urlname/aspnum这两项，返回第二个session对象。
爬虫对象是一个返回列表并列举着所有已爬取url的web服务器。可以看到url这个数组不包含参数，而web服务器这个函数不是很难的，可以读取文件，referer当然也是用来设置必要参数的。既然是request方法，可以看下响应的处理，item是http请求内容，headers当然是必要参数了，和request是一样的。
//name是giteawall.py的name方法classgiteawall:def__init__(self,name):self.name=nameself.spider。 查看全部
scrapy分页抓取网页信息实现网络爬虫和抓包分析器-scrapy中文文档-csdn博客-中国最大的it技术社区scrapy是一个开源的pythonweb框架，它提供了一个功能强大的networkapi，可以让爬虫获取网络网页信息和重定向网页从而爬取动态网页。scrapy的核心是用于在scrapyweb框架中创建和利用多线程抓取和分析网页的核心功能。
scrapy通过分层的scrapyweb框架将请求或响应流传递给下游爬虫/job可以进行不同的数据抓取。scrapy支持windows、linux和mac系统。我们分别在mac和windows系统环境下做演示。scrapy分页抓取网页信息实现代码：importscrapyclassglobaljsonitem:name=scrapy.field(scrapy.field())aspnum=scrapy.field(scrapy.field())url=''headers={'user-agent':'mozilla/5.0(windowsnt10.0;win64;x64)applewebkit/537.36(khtml,likegecko)chrome/72.0.3440.137safari/537.36'}referer=scrapy.get(headers=headers)scrapy.request(url=url,post=globaljsonitem,headers=headers)scrapy.items().urlparameter('url',list(request.text))fig=plt.figure()a=fig.add_subplot(2,2,1)name=globaljsonitem(a)aspnum=globaljsonitem(a)url=''url=''partial=globaljsonitem(aspnum)url='"\s+"\s+"\s+"\s+"+"\s+"\s+"\s+"+"\s+"\s+"+"\s+"'content=scrapy.extract_text(url,encoding='utf-8')withopen('test.txt','w+')asfp:fp.write(content)请求进入到后台，content.follow('/')，可以看到，此时请求是从创建爬虫的giteawall.py文件开始抓取下来的，爬虫之后，就可以去掉设置参数/urlname/aspnum这两项，返回第二个session对象。
爬虫对象是一个返回列表并列举着所有已爬取url的web服务器。可以看到url这个数组不包含参数，而web服务器这个函数不是很难的，可以读取文件，referer当然也是用来设置必要参数的。既然是request方法，可以看下响应的处理，item是http请求内容，headers当然是必要参数了，和request是一样的。
//name是giteawall.py的name方法classgiteawall:def__init__(self,name):self.name=nameself.spider。 查看全部
scrapy分页抓取网页(scrapy分页抓取网页信息实现网络爬虫和抓包分析器-scrapy)
scrapy分页抓取网页信息实现网络爬虫和抓包分析器-scrapy中文文档-csdn博客-中国最大的it技术社区scrapy是一个开源的pythonweb框架，它提供了一个功能强大的networkapi，可以让爬虫获取网络网页信息和重定向网页从而爬取动态网页。scrapy的核心是用于在scrapyweb框架中创建和利用多线程抓取和分析网页的核心功能。
scrapy通过分层的scrapyweb框架将请求或响应流传递给下游爬虫/job可以进行不同的数据抓取。scrapy支持windows、linux和mac系统。我们分别在mac和windows系统环境下做演示。scrapy分页抓取网页信息实现代码：importscrapyclassglobaljsonitem:name=scrapy.field(scrapy.field())aspnum=scrapy.field(scrapy.field())url=''headers={'user-agent':'mozilla/5.0(windowsnt10.0;win64;x64)applewebkit/537.36(khtml,likegecko)chrome/72.0.3440.137safari/537.36'}referer=scrapy.get(headers=headers)scrapy.request(url=url,post=globaljsonitem,headers=headers)scrapy.items().urlparameter('url',list(request.text))fig=plt.figure()a=fig.add_subplot(2,2,1)name=globaljsonitem(a)aspnum=globaljsonitem(a)url=''url=''partial=globaljsonitem(aspnum)url='"\s+"\s+"\s+"\s+"+"\s+"\s+"\s+"+"\s+"\s+"+"\s+"'content=scrapy.extract_text(url,encoding='utf-8')withopen('test.txt','w+')asfp:fp.write(content)请求进入到后台，content.follow('/')，可以看到，此时请求是从创建爬虫的giteawall.py文件开始抓取下来的，爬虫之后，就可以去掉设置参数/urlname/aspnum这两项，返回第二个session对象。
爬虫对象是一个返回列表并列举着所有已爬取url的web服务器。可以看到url这个数组不包含参数，而web服务器这个函数不是很难的，可以读取文件，referer当然也是用来设置必要参数的。既然是request方法，可以看下响应的处理，item是http请求内容，headers当然是必要参数了，和request是一样的。
//name是giteawall.py的name方法classgiteawall:def__init__(self,name):self.name=nameself.spider。
scrapy分页抓取网页(一下爬虫爬虫项目的基本步骤和基本操作步骤（一）)
网站优化 • 优采云 发表了文章 • 0 个评论 • 50 次浏览 • 2022-02-11 10:16
scrapy分页抓取网页(一下爬虫爬虫项目的基本步骤和基本操作步骤（一）)
Python爬虫--scrapy爬虫框架介绍写在前面
在编写爬虫之前，我从未使用过爬虫框架。其实我之前写的就是一个爬虫写的小练习的demo。只能说是从网上抓取一点数据，直接用python脚本解决爬虫的所有功能。循环获取更多数据页。后来了解了代理池系统，稍微了解了一下爬虫其实也可以算是一个项目。该项目分为模块。不同的模块负责不同的功能。有些模块负责封装http请求，有些模块负责处理请求。（数据采集），有些模块负责数据分析，有些模块负责数据存储。这样一个框架的原型已经出现，这可以帮助我们更加专注和高效地抓取数据。对于scrapy，一开始并不想解释scrapy框架的太多部分和功能，而是直接在实际操作中去感受一下框架是如何分工协作的，各个模块负责什么功能，最后关注一下这个框架。一些原则应该是学习scrapy框架的最好方法。
scrapy爬虫的基本步骤创建一个scrapy爬虫项目。创建一个 Spider 爬虫类来爬取网页内容并解析它。定义数据模型（Item）并将捕获的数据封装到Item中。使用Item Pipeline来存储和抓取Items，即数据实体对象。一、创建一个scrapy爬虫项目
安装scrapy后，运行命令scrapy startproject project name，创建scrapy爬虫项目。例如运行scrapy startproject test1会生成一个test1文件夹，目录结构如下：
二、创建一个Spider爬虫类来爬取网页内容并解析它。
爬虫的代码写在spider文件夹下，所以在spider目录下创建一个python文件，爬取方天下的数据，所以创建一个python文件，命名为ftx_spider.py。
接下来，开始在 ftx_spider.py 中编写爬虫代码：
import scrapy
class FtxSpider(scrapy.Spider):
"""
一、创建一个爬虫类，继承scrapy.Spider
二、通过name属性，给爬虫类定义一个名称
三、指定要抓取的网页链接urls，发送http请求
方式一：
1.继承scrapy.Spider的start_requests()方法。
2.指定要爬取的url，通过scrapy.Request(url=url, callback=self.parse)发送请求，callback指定解析函数。
方式二(简化)：
1.直接通过start_urls常量指定要爬取的urls。
2.框架会自动发送http请求，这里框架默认html解析函数parse().
四、针对http请求的response结果，编写解析方法，parse()
"""
name = 'ftx'
# 方式一：通过scrapy.Request(url=url, callback=self.parse)发送请求，指定解析函数
# def start_requests(self):
# urls = ['http://wuhan.esf.fang.com/hous ... 39%3B]
# for url in urls:
# yield scrapy.Request(url=url, callback=self.parse)
#
# def parse(self, response):
# # 这里对抓取到的html页面进行解析
# print(response.url)
# 方式二(简化版)：通过start_urls，框架自动发送请求，默认解析函数为parse()
start_urls = ['http://wuhan.esf.fang.com/hous ... 39%3B]
def parse(self, response):
print(response.url)
三、数据模型Item，定义爬取数据的数据结构
这个Item相当于java中的域实体，或者javabean。在 items.py 中定义了一个类，它继承了 scrapy.Item。这样我们就可以将我们抓取的数据封装到一个对象中。
import scrapy
class FtxSpiderItem(scrapy.Item):
# define the fields for your item here like:
title = scrapy.Field() # 标题
huxing = scrapy.Field() # 户型
size = scrapy.Field() # 面积
floor = scrapy.Field() # 楼层
fangxiang = scrapy.Field() # 方向
year = scrapy.Field() # 建房时间
shop_community = scrapy.Field() # 小区
address = scrapy.Field() # 地址
total_price = scrapy.Field() # 总价（万）
price = scrapy.Field() # 单价（万/m2）
四、使用Item Pipeline存储和抓取item并将数据存储在MongoDB中
项目管道是项目管道。当 Item 生成后，会自动发送到 Item Pipeline 进行处理。
首先在setting.py中添加MongoDB数据库连接信息
# MongoDB
HOST = 'localhost'
PORT = 27017
DB_NAME = 'ftx'
COLL_NAME = 'roomprice'
然后在pipelines.py中创建一个类，连接数据库，插入数据
import pymongo
from scrapy.conf import settings
class FtxSpiderPipeline(object):
def __init__(self):
# 连接MongoDB
self.client = pymongo.MongoClient(host=settings['HOST'], port=settings['PORT'])
# 获取数据库
self.db = self.client[settings['DB_NAME']]
# 获取集合
self.collection = self.db[settings['COLL_NAME']]
def process_item(self, item, spider):
self.collection.insert(dict(item))
最后在setting.py中指定Item Pipeline使用的类和优先级
ITEM_PIPELINES = {
'ftx_spider.pipelines.FtxSpiderPipeline': 300
}
运行命令行scrapy crawl 'crawler name name'，可以发现数据已经成功存入数据库，代码地址完整 查看全部
Python爬虫--scrapy爬虫框架介绍写在前面
在编写爬虫之前，我从未使用过爬虫框架。其实我之前写的就是一个爬虫写的小练习的demo。只能说是从网上抓取一点数据，直接用python脚本解决爬虫的所有功能。循环获取更多数据页。后来了解了代理池系统，稍微了解了一下爬虫其实也可以算是一个项目。该项目分为模块。不同的模块负责不同的功能。有些模块负责封装http请求，有些模块负责处理请求。（数据采集），有些模块负责数据分析，有些模块负责数据存储。这样一个框架的原型已经出现，这可以帮助我们更加专注和高效地抓取数据。对于scrapy，一开始并不想解释scrapy框架的太多部分和功能，而是直接在实际操作中去感受一下框架是如何分工协作的，各个模块负责什么功能，最后关注一下这个框架。一些原则应该是学习scrapy框架的最好方法。
scrapy爬虫的基本步骤创建一个scrapy爬虫项目。创建一个 Spider 爬虫类来爬取网页内容并解析它。定义数据模型（Item）并将捕获的数据封装到Item中。使用Item Pipeline来存储和抓取Items，即数据实体对象。一、创建一个scrapy爬虫项目
安装scrapy后，运行命令scrapy startproject project name，创建scrapy爬虫项目。例如运行scrapy startproject test1会生成一个test1文件夹，目录结构如下：
二、创建一个Spider爬虫类来爬取网页内容并解析它。
爬虫的代码写在spider文件夹下，所以在spider目录下创建一个python文件，爬取方天下的数据，所以创建一个python文件，命名为ftx_spider.py。
接下来，开始在 ftx_spider.py 中编写爬虫代码：
import scrapy
class FtxSpider(scrapy.Spider):
"""
一、创建一个爬虫类，继承scrapy.Spider
二、通过name属性，给爬虫类定义一个名称
三、指定要抓取的网页链接urls，发送http请求
方式一：
1.继承scrapy.Spider的start_requests()方法。
2.指定要爬取的url，通过scrapy.Request(url=url, callback=self.parse)发送请求，callback指定解析函数。
方式二(简化)：
1.直接通过start_urls常量指定要爬取的urls。
2.框架会自动发送http请求，这里框架默认html解析函数parse().
四、针对http请求的response结果，编写解析方法，parse()
"""
name = 'ftx'
# 方式一：通过scrapy.Request(url=url, callback=self.parse)发送请求，指定解析函数
# def start_requests(self):
# urls = ['http://wuhan.esf.fang.com/hous ... 39%3B]
# for url in urls:
# yield scrapy.Request(url=url, callback=self.parse)
#
# def parse(self, response):
# # 这里对抓取到的html页面进行解析
# print(response.url)
# 方式二(简化版)：通过start_urls，框架自动发送请求，默认解析函数为parse()
start_urls = ['http://wuhan.esf.fang.com/hous ... 39%3B]
def parse(self, response):
print(response.url)
三、数据模型Item，定义爬取数据的数据结构
这个Item相当于java中的域实体，或者javabean。在 items.py 中定义了一个类，它继承了 scrapy.Item。这样我们就可以将我们抓取的数据封装到一个对象中。
import scrapy
class FtxSpiderItem(scrapy.Item):
# define the fields for your item here like:
title = scrapy.Field() # 标题
huxing = scrapy.Field() # 户型
size = scrapy.Field() # 面积
floor = scrapy.Field() # 楼层
fangxiang = scrapy.Field() # 方向
year = scrapy.Field() # 建房时间
shop_community = scrapy.Field() # 小区
address = scrapy.Field() # 地址
total_price = scrapy.Field() # 总价（万）
price = scrapy.Field() # 单价（万/m2）
四、使用Item Pipeline存储和抓取item并将数据存储在MongoDB中
项目管道是项目管道。当 Item 生成后，会自动发送到 Item Pipeline 进行处理。
首先在setting.py中添加MongoDB数据库连接信息
# MongoDB
HOST = 'localhost'
PORT = 27017
DB_NAME = 'ftx'
COLL_NAME = 'roomprice'
然后在pipelines.py中创建一个类，连接数据库，插入数据
import pymongo
from scrapy.conf import settings
class FtxSpiderPipeline(object):
def __init__(self):
# 连接MongoDB
self.client = pymongo.MongoClient(host=settings['HOST'], port=settings['PORT'])
# 获取数据库
self.db = self.client[settings['DB_NAME']]
# 获取集合
self.collection = self.db[settings['COLL_NAME']]
def process_item(self, item, spider):
self.collection.insert(dict(item))
最后在setting.py中指定Item Pipeline使用的类和优先级
ITEM_PIPELINES = {
'ftx_spider.pipelines.FtxSpiderPipeline': 300
}
运行命令行scrapy crawl 'crawler name name'，可以发现数据已经成功存入数据库，代码地址完整 查看全部
scrapy分页抓取网页(一下爬虫爬虫项目的基本步骤和基本操作步骤（一）)
Python爬虫--scrapy爬虫框架介绍写在前面
在编写爬虫之前，我从未使用过爬虫框架。其实我之前写的就是一个爬虫写的小练习的demo。只能说是从网上抓取一点数据，直接用python脚本解决爬虫的所有功能。循环获取更多数据页。后来了解了代理池系统，稍微了解了一下爬虫其实也可以算是一个项目。该项目分为模块。不同的模块负责不同的功能。有些模块负责封装http请求，有些模块负责处理请求。（数据采集），有些模块负责数据分析，有些模块负责数据存储。这样一个框架的原型已经出现，这可以帮助我们更加专注和高效地抓取数据。对于scrapy，一开始并不想解释scrapy框架的太多部分和功能，而是直接在实际操作中去感受一下框架是如何分工协作的，各个模块负责什么功能，最后关注一下这个框架。一些原则应该是学习scrapy框架的最好方法。
scrapy爬虫的基本步骤创建一个scrapy爬虫项目。创建一个 Spider 爬虫类来爬取网页内容并解析它。定义数据模型（Item）并将捕获的数据封装到Item中。使用Item Pipeline来存储和抓取Items，即数据实体对象。一、创建一个scrapy爬虫项目
安装scrapy后，运行命令scrapy startproject project name，创建scrapy爬虫项目。例如运行scrapy startproject test1会生成一个test1文件夹，目录结构如下：
二、创建一个Spider爬虫类来爬取网页内容并解析它。
爬虫的代码写在spider文件夹下，所以在spider目录下创建一个python文件，爬取方天下的数据，所以创建一个python文件，命名为ftx_spider.py。
接下来，开始在 ftx_spider.py 中编写爬虫代码：
import scrapy
class FtxSpider(scrapy.Spider):
"""
一、创建一个爬虫类，继承scrapy.Spider
二、通过name属性，给爬虫类定义一个名称
三、指定要抓取的网页链接urls，发送http请求
方式一：
1.继承scrapy.Spider的start_requests()方法。
2.指定要爬取的url，通过scrapy.Request(url=url, callback=self.parse)发送请求，callback指定解析函数。
方式二(简化)：
1.直接通过start_urls常量指定要爬取的urls。
2.框架会自动发送http请求，这里框架默认html解析函数parse().
四、针对http请求的response结果，编写解析方法，parse()
"""
name = 'ftx'
# 方式一：通过scrapy.Request(url=url, callback=self.parse)发送请求，指定解析函数
# def start_requests(self):
# urls = ['http://wuhan.esf.fang.com/hous ... 39%3B]
# for url in urls:
# yield scrapy.Request(url=url, callback=self.parse)
#
# def parse(self, response):
# # 这里对抓取到的html页面进行解析
# print(response.url)
# 方式二(简化版)：通过start_urls，框架自动发送请求，默认解析函数为parse()
start_urls = ['http://wuhan.esf.fang.com/hous ... 39%3B]
def parse(self, response):
print(response.url)
三、数据模型Item，定义爬取数据的数据结构
这个Item相当于java中的域实体，或者javabean。在 items.py 中定义了一个类，它继承了 scrapy.Item。这样我们就可以将我们抓取的数据封装到一个对象中。
import scrapy
class FtxSpiderItem(scrapy.Item):
# define the fields for your item here like:
title = scrapy.Field() # 标题
huxing = scrapy.Field() # 户型
size = scrapy.Field() # 面积
floor = scrapy.Field() # 楼层
fangxiang = scrapy.Field() # 方向
year = scrapy.Field() # 建房时间
shop_community = scrapy.Field() # 小区
address = scrapy.Field() # 地址
total_price = scrapy.Field() # 总价（万）
price = scrapy.Field() # 单价（万/m2）
四、使用Item Pipeline存储和抓取item并将数据存储在MongoDB中
项目管道是项目管道。当 Item 生成后，会自动发送到 Item Pipeline 进行处理。
首先在setting.py中添加MongoDB数据库连接信息
# MongoDB
HOST = 'localhost'
PORT = 27017
DB_NAME = 'ftx'
COLL_NAME = 'roomprice'
然后在pipelines.py中创建一个类，连接数据库，插入数据
import pymongo
from scrapy.conf import settings
class FtxSpiderPipeline(object):
def __init__(self):
# 连接MongoDB
self.client = pymongo.MongoClient(host=settings['HOST'], port=settings['PORT'])
# 获取数据库
self.db = self.client[settings['DB_NAME']]
# 获取集合
self.collection = self.db[settings['COLL_NAME']]
def process_item(self, item, spider):
self.collection.insert(dict(item))
最后在setting.py中指定Item Pipeline使用的类和优先级
ITEM_PIPELINES = {
'ftx_spider.pipelines.FtxSpiderPipeline': 300
}
运行命令行scrapy crawl 'crawler name name'，可以发现数据已经成功存入数据库，代码地址完整
scrapy分页抓取网页(蜘蛛池博客原文链接：如何让网站更符合搜索引擎的抓取规则？)
网站优化 • 优采云 发表了文章 • 0 个评论 • 94 次浏览 • 2022-02-11 08:23
scrapy分页抓取网页(蜘蛛池博客原文链接：如何让网站更符合搜索引擎的抓取规则？)
原文来源：蜘蛛池博客
原文链接：如何让网站更符合搜索引擎的爬取规则？- 蜘蛛池博客
如果一个网站可以被搜索引擎频繁爬取，说明搜索引擎非常信任这个网站，所以赋予网站的权重也很高，关键词排名，网站流量会上升。那么，如何让网站更符合搜索引擎的爬取规则呢？接下来，蜘蛛池博客的小编给大家分享一下更符合搜索引擎爬取的规则网站，一起来看看吧！
1.设置清晰网站地图
说到网站图，很不起眼，相信很容易被大家忽略。当搜索引擎来到网站时，一开始并不清楚这个网站有哪些页面，哪些是新添加的，哪些是原来的。网站的所有页面一目了然，让搜索引擎对网站的所有页面一目了然，而不是一一查找。通过网站图，搜索引擎可以快速浏览整个网站的内容，快速爬取收录页面，这样网站收录就是很快，搜索引擎也愿意经常来网站。
2.网站结构和层次
网站 的结构非常重要。现在网站的结构主要有两种，一种是扁平结构，一种是树状结构。现在市场主要以树结构为主。它很容易管理。对于 网站 级别，它不应该太深。一般建议在三个级别以内。首页是一级，栏目页和分类页是一级，信息详情页和产品详情页是一级。这个三级页面方便蜘蛛快速爬取页面和内容。网站必须简化代码，以便蜘蛛能够快速爬行。
3.优质外链吸引蜘蛛
每天发布优质内容是一件很悲哀的事情，但百度蜘蛛并不在意。因此，对于很多外链强的老网站来说，建立优质的外链和访问渠道是没有问题的。如果你的 网站 是一个新站点，并且外部链接很少，你可以采取这种方法。新的内容页面发布后，会去一些优质的平台或新闻源外链，很快蜘蛛就会从这些网站爬到你那里。对新的内容页面进行爬网和索引。
4.内容页面质量
内容页面的质量是网站优化的重中之重。只有质量更好的内容才能吸引蜘蛛爬取，同时才能留住用户对你网站的关注；搜索引擎蜘蛛完成爬取后，下一步就是索引。如果这一步成功，我们的内容就可以进入百度的数据库，下一步就可以展示在用户面前了。
5.网站的更新频率
蜘蛛会存储每次爬取的网站，方便第二次爬取。如果第二次爬到你优化的网站，发现页面已经更新，蜘蛛就会爬到你的新内容每天更新，蜘蛛也会养成爬你的网站的习惯每天定期。
<p>总结：以上就是蜘蛛池博客小编想跟大家分享的，比较符合搜索引擎爬取网站的规则，希望对大家 查看全部
原文来源：蜘蛛池博客
原文链接：如何让网站更符合搜索引擎的爬取规则？- 蜘蛛池博客
如果一个网站可以被搜索引擎频繁爬取，说明搜索引擎非常信任这个网站，所以赋予网站的权重也很高，关键词排名，网站流量会上升。那么，如何让网站更符合搜索引擎的爬取规则呢？接下来，蜘蛛池博客的小编给大家分享一下更符合搜索引擎爬取的规则网站，一起来看看吧！
1.设置清晰网站地图
说到网站图，很不起眼，相信很容易被大家忽略。当搜索引擎来到网站时，一开始并不清楚这个网站有哪些页面，哪些是新添加的，哪些是原来的。网站的所有页面一目了然，让搜索引擎对网站的所有页面一目了然，而不是一一查找。通过网站图，搜索引擎可以快速浏览整个网站的内容，快速爬取收录页面，这样网站收录就是很快，搜索引擎也愿意经常来网站。
2.网站结构和层次
网站 的结构非常重要。现在网站的结构主要有两种，一种是扁平结构，一种是树状结构。现在市场主要以树结构为主。它很容易管理。对于 网站 级别，它不应该太深。一般建议在三个级别以内。首页是一级，栏目页和分类页是一级，信息详情页和产品详情页是一级。这个三级页面方便蜘蛛快速爬取页面和内容。网站必须简化代码，以便蜘蛛能够快速爬行。
3.优质外链吸引蜘蛛
每天发布优质内容是一件很悲哀的事情，但百度蜘蛛并不在意。因此，对于很多外链强的老网站来说，建立优质的外链和访问渠道是没有问题的。如果你的 网站 是一个新站点，并且外部链接很少，你可以采取这种方法。新的内容页面发布后，会去一些优质的平台或新闻源外链，很快蜘蛛就会从这些网站爬到你那里。对新的内容页面进行爬网和索引。
4.内容页面质量
内容页面的质量是网站优化的重中之重。只有质量更好的内容才能吸引蜘蛛爬取，同时才能留住用户对你网站的关注；搜索引擎蜘蛛完成爬取后，下一步就是索引。如果这一步成功，我们的内容就可以进入百度的数据库，下一步就可以展示在用户面前了。
5.网站的更新频率
蜘蛛会存储每次爬取的网站，方便第二次爬取。如果第二次爬到你优化的网站，发现页面已经更新，蜘蛛就会爬到你的新内容每天更新，蜘蛛也会养成爬你的网站的习惯每天定期。
<p>总结：以上就是蜘蛛池博客小编想跟大家分享的，比较符合搜索引擎爬取网站的规则，希望对大家 查看全部
scrapy分页抓取网页(蜘蛛池博客原文链接：如何让网站更符合搜索引擎的抓取规则？)
原文来源：蜘蛛池博客
原文链接：如何让网站更符合搜索引擎的爬取规则？- 蜘蛛池博客
如果一个网站可以被搜索引擎频繁爬取，说明搜索引擎非常信任这个网站，所以赋予网站的权重也很高，关键词排名，网站流量会上升。那么，如何让网站更符合搜索引擎的爬取规则呢？接下来，蜘蛛池博客的小编给大家分享一下更符合搜索引擎爬取的规则网站，一起来看看吧！
1.设置清晰网站地图
说到网站图，很不起眼，相信很容易被大家忽略。当搜索引擎来到网站时，一开始并不清楚这个网站有哪些页面，哪些是新添加的，哪些是原来的。网站的所有页面一目了然，让搜索引擎对网站的所有页面一目了然，而不是一一查找。通过网站图，搜索引擎可以快速浏览整个网站的内容，快速爬取收录页面，这样网站收录就是很快，搜索引擎也愿意经常来网站。
2.网站结构和层次
网站 的结构非常重要。现在网站的结构主要有两种，一种是扁平结构，一种是树状结构。现在市场主要以树结构为主。它很容易管理。对于 网站 级别，它不应该太深。一般建议在三个级别以内。首页是一级，栏目页和分类页是一级，信息详情页和产品详情页是一级。这个三级页面方便蜘蛛快速爬取页面和内容。网站必须简化代码，以便蜘蛛能够快速爬行。
3.优质外链吸引蜘蛛
每天发布优质内容是一件很悲哀的事情，但百度蜘蛛并不在意。因此，对于很多外链强的老网站来说，建立优质的外链和访问渠道是没有问题的。如果你的 网站 是一个新站点，并且外部链接很少，你可以采取这种方法。新的内容页面发布后，会去一些优质的平台或新闻源外链，很快蜘蛛就会从这些网站爬到你那里。对新的内容页面进行爬网和索引。
4.内容页面质量
内容页面的质量是网站优化的重中之重。只有质量更好的内容才能吸引蜘蛛爬取，同时才能留住用户对你网站的关注；搜索引擎蜘蛛完成爬取后，下一步就是索引。如果这一步成功，我们的内容就可以进入百度的数据库，下一步就可以展示在用户面前了。
5.网站的更新频率
蜘蛛会存储每次爬取的网站，方便第二次爬取。如果第二次爬到你优化的网站，发现页面已经更新，蜘蛛就会爬到你的新内容每天更新，蜘蛛也会养成爬你的网站的习惯每天定期。
<p>总结：以上就是蜘蛛池博客小编想跟大家分享的，比较符合搜索引擎爬取网站的规则，希望对大家
scrapy分页抓取网页(WebScraper的一个扩展插件，安装后你可以直接在F12调试工具里使用)
网站优化 • 优采云 发表了文章 • 0 个评论 • 49 次浏览 • 2022-02-08 06:23
scrapy分页抓取网页(WebScraper的一个扩展插件，安装后你可以直接在F12调试工具里使用)
经常遇到一些简单的需求，需要在某个网站上爬取一些数据，但是这些页面的结构很简单，数据量也比较少。自己写代码是可以的，但是没用。牛刀？
目前市面上有一些成熟的零码爬虫工具，比如优采云，有现成的模板可以使用，一些爬取规则也可以自己定义。但是我今天要介绍的是另一个神器——Web Scraper，它是Chrome浏览器的扩展。安装后，可以直接在F12调试工具中使用。
# 1. 安装网络爬虫
有条件的同学，可以直接在商店搜索Web Scraper进行安装
没有条件的同学可以到这个网站(/)下载crx文件，然后离线安装。具体方法可以借助搜索引擎解决。
安装后需要重启一次Chrome，然后F12才能看到工具
# 2. 基本概念和操作
在使用 Web Scraper 之前，需要先解释一下它的一些基本概念：
网站地图
直译为网站map，有了这个地图爬虫就可以跟着它获取我们需要的数据。
所以sitemap其实可以理解为网站的爬虫程序。要爬取多个 网站 数据，需要定义多个站点地图。
站点地图支持导出和导入，这意味着您编写的站点地图可以与他人共享。
从下图可以看出，sitemap代码是一串JSON配置
只要拿到这个配置，就可以导入别人的站点地图
选择器
直译过来就是一个选择器。要从一个充满数据的 HTML 页面中提取数据，需要一个选择器来定位我们数据的具体位置。
每个 Selector 可以获取一条数据。要获取多条数据，需要定位多个 Selector。
Web Scraper 提供的 Selector 有很多，但本文文章 只介绍几个使用最频繁、覆盖面最广的 Selector。了解一二之后，其他的原理都差不多。可以上手了。
Web Scraper 使用 CSS 选择器来定位元素。如果你不知道，没关系。在大多数场景下，您可以直接通过鼠标点击选择元素，Web Scraper 会自动解析相应的 CSS。小路。
Selector 可以嵌套，子 Selector 的 CSS 选择器作用域就是父 Selector。
正是这种无穷无尽的嵌套关系让我们能够递归地爬取整个 网站 数据。
下面是我们后面经常放的选择器拓扑，可以用来直观的展示Web Scraper的爬取逻辑
数据抓取和导出
定义站点地图规则后，单击“抓取”开始抓取数据。
爬取数据后，不会立即显示在页面上，需要再次手动点击刷新按钮才能看到数据。
最终数据也可以导出为 csv 或 xlsx 文件。
# 3. 寻呼机爬取
爬取数据最经典的模型是列表、分页和明细。接下来我也会围绕这个方向爬取CSDN博客文章来介绍几个Selector的用法。
寻呼机可以分为两种类型：
在早期版本的 web-scraper 中，两种爬取方式是不同的。
对于一些 网站 来说确实足够了，但有很大的局限性。
经过我的实验，使用Link选择器的第一个原理是在下一页取出a标签的超链接，然后访问它，但并不是所有网站的下一页都是通过a标签实现的.
如果用js监听事件然后像下面这样跳转，就不能使用Link选择器了。
在新版本的网络爬虫中，它提供了对导航分页器的特殊支持，并增加了一个分页选择器，可以完全适用于两种场景，我将在下面进行演示。
寻呼机爬行而不重新加载页面
点击具体的CSDN博文，拉到底部，就可以看到评论区了。
如果你的文章比较热门，有很多同学评论，CSDN会分页显示，但是不管在哪个页面评论都属于同一篇文章文章，你浏览的时候当你在任何页面的评论区时，博文不需要刷新，因为这个分页不会重新加载页面。
对于这种不需要重新加载页面的点击，可以使用Element Click来解决。
最后一点必须注意，要选择root和next_page，只有这样才能递归爬取
最终爬取效果如下
使用Element Click的站点地图配置如下，可以直接导入我的配置进行研究，下载配置文件：/iidSSugkch
当然，对于分页之类的东西，网页爬虫提供了更专业的分页选择器，配置更精简，效果最好。
对应sitemap的配置如下，可以直接导入使用。下载配置文件：/iidSSugkch
寻呼机爬行以重新加载页面
CSDN的博客文章列表，拉到底部，点击具体页面按钮，否则最右边的下一页会重新加载当前页面。
对于这种分页器，Element Click 什么都做不了，读者可以自行验证，最多爬一页就会关闭。
而且作为一个为分页而生的Pagination选择器，自然适用
爬取的拓扑同上，这里不再赘述。
对应sitemap的配置如下，可以直接导入学习，下载配置文件：/iidSSugkch
# 4. 次要页面的爬取
CSDN的博客列表列表页，显示的信息比较粗略，只有标题，发表时间，阅读量，评论数，是否是原创。
如果你想获得更多的信息，比如博文的文字、点赞数、采集数、评论区的内容，你必须点击具体的博文链接才能查看。
网络爬虫的操作逻辑与人类相同。如果你想抓取更详细的博文信息，你必须打开一个新的页面来获取它，而网络爬虫的链接选择器恰好做到了这一点。
爬取路径拓扑如下
爬取的效果如下
sitemap的配置如下，可以直接导入使用。下载配置文件：/iidSSugkch
# 5. 最后
以上整理了分页和二级页面的爬取方案，主要有：分页器爬取和二级页面爬取。
只要学会了这两个，就已经可以处理绝大多数结构化的网络数据了。 查看全部
经常遇到一些简单的需求，需要在某个网站上爬取一些数据，但是这些页面的结构很简单，数据量也比较少。自己写代码是可以的，但是没用。牛刀？
目前市面上有一些成熟的零码爬虫工具，比如优采云，有现成的模板可以使用，一些爬取规则也可以自己定义。但是我今天要介绍的是另一个神器——Web Scraper，它是Chrome浏览器的扩展。安装后，可以直接在F12调试工具中使用。
# 1. 安装网络爬虫
有条件的同学，可以直接在商店搜索Web Scraper进行安装
没有条件的同学可以到这个网站(/)下载crx文件，然后离线安装。具体方法可以借助搜索引擎解决。
安装后需要重启一次Chrome，然后F12才能看到工具
# 2. 基本概念和操作
在使用 Web Scraper 之前，需要先解释一下它的一些基本概念：
网站地图
直译为网站map，有了这个地图爬虫就可以跟着它获取我们需要的数据。
所以sitemap其实可以理解为网站的爬虫程序。要爬取多个 网站 数据，需要定义多个站点地图。
站点地图支持导出和导入，这意味着您编写的站点地图可以与他人共享。
从下图可以看出，sitemap代码是一串JSON配置
只要拿到这个配置，就可以导入别人的站点地图
选择器
直译过来就是一个选择器。要从一个充满数据的 HTML 页面中提取数据，需要一个选择器来定位我们数据的具体位置。
每个 Selector 可以获取一条数据。要获取多条数据，需要定位多个 Selector。
Web Scraper 提供的 Selector 有很多，但本文文章 只介绍几个使用最频繁、覆盖面最广的 Selector。了解一二之后，其他的原理都差不多。可以上手了。
Web Scraper 使用 CSS 选择器来定位元素。如果你不知道，没关系。在大多数场景下，您可以直接通过鼠标点击选择元素，Web Scraper 会自动解析相应的 CSS。小路。
Selector 可以嵌套，子 Selector 的 CSS 选择器作用域就是父 Selector。
正是这种无穷无尽的嵌套关系让我们能够递归地爬取整个 网站 数据。
下面是我们后面经常放的选择器拓扑，可以用来直观的展示Web Scraper的爬取逻辑
数据抓取和导出
定义站点地图规则后，单击“抓取”开始抓取数据。
爬取数据后，不会立即显示在页面上，需要再次手动点击刷新按钮才能看到数据。
最终数据也可以导出为 csv 或 xlsx 文件。
# 3. 寻呼机爬取
爬取数据最经典的模型是列表、分页和明细。接下来我也会围绕这个方向爬取CSDN博客文章来介绍几个Selector的用法。
寻呼机可以分为两种类型：
在早期版本的 web-scraper 中，两种爬取方式是不同的。
对于一些 网站 来说确实足够了，但有很大的局限性。
经过我的实验，使用Link选择器的第一个原理是在下一页取出a标签的超链接，然后访问它，但并不是所有网站的下一页都是通过a标签实现的.
如果用js监听事件然后像下面这样跳转，就不能使用Link选择器了。
在新版本的网络爬虫中，它提供了对导航分页器的特殊支持，并增加了一个分页选择器，可以完全适用于两种场景，我将在下面进行演示。
寻呼机爬行而不重新加载页面
点击具体的CSDN博文，拉到底部，就可以看到评论区了。
如果你的文章比较热门，有很多同学评论，CSDN会分页显示，但是不管在哪个页面评论都属于同一篇文章文章，你浏览的时候当你在任何页面的评论区时，博文不需要刷新，因为这个分页不会重新加载页面。
对于这种不需要重新加载页面的点击，可以使用Element Click来解决。
最后一点必须注意，要选择root和next_page，只有这样才能递归爬取
最终爬取效果如下
使用Element Click的站点地图配置如下，可以直接导入我的配置进行研究，下载配置文件：/iidSSugkch
当然，对于分页之类的东西，网页爬虫提供了更专业的分页选择器，配置更精简，效果最好。
对应sitemap的配置如下，可以直接导入使用。下载配置文件：/iidSSugkch
寻呼机爬行以重新加载页面
CSDN的博客文章列表，拉到底部，点击具体页面按钮，否则最右边的下一页会重新加载当前页面。
对于这种分页器，Element Click 什么都做不了，读者可以自行验证，最多爬一页就会关闭。
而且作为一个为分页而生的Pagination选择器，自然适用
爬取的拓扑同上，这里不再赘述。
对应sitemap的配置如下，可以直接导入学习，下载配置文件：/iidSSugkch
# 4. 次要页面的爬取
CSDN的博客列表列表页，显示的信息比较粗略，只有标题，发表时间，阅读量，评论数，是否是原创。
如果你想获得更多的信息，比如博文的文字、点赞数、采集数、评论区的内容，你必须点击具体的博文链接才能查看。
网络爬虫的操作逻辑与人类相同。如果你想抓取更详细的博文信息，你必须打开一个新的页面来获取它，而网络爬虫的链接选择器恰好做到了这一点。
爬取路径拓扑如下
爬取的效果如下
sitemap的配置如下，可以直接导入使用。下载配置文件：/iidSSugkch
# 5. 最后
以上整理了分页和二级页面的爬取方案，主要有：分页器爬取和二级页面爬取。
只要学会了这两个，就已经可以处理绝大多数结构化的网络数据了。 查看全部
scrapy分页抓取网页(WebScraper的一个扩展插件，安装后你可以直接在F12调试工具里使用)
经常遇到一些简单的需求，需要在某个网站上爬取一些数据，但是这些页面的结构很简单，数据量也比较少。自己写代码是可以的，但是没用。牛刀？
目前市面上有一些成熟的零码爬虫工具，比如优采云，有现成的模板可以使用，一些爬取规则也可以自己定义。但是我今天要介绍的是另一个神器——Web Scraper，它是Chrome浏览器的扩展。安装后，可以直接在F12调试工具中使用。
# 1. 安装网络爬虫
有条件的同学，可以直接在商店搜索Web Scraper进行安装
没有条件的同学可以到这个网站(/)下载crx文件，然后离线安装。具体方法可以借助搜索引擎解决。
安装后需要重启一次Chrome，然后F12才能看到工具
# 2. 基本概念和操作
在使用 Web Scraper 之前，需要先解释一下它的一些基本概念：
网站地图
直译为网站map，有了这个地图爬虫就可以跟着它获取我们需要的数据。
所以sitemap其实可以理解为网站的爬虫程序。要爬取多个 网站 数据，需要定义多个站点地图。
站点地图支持导出和导入，这意味着您编写的站点地图可以与他人共享。
从下图可以看出，sitemap代码是一串JSON配置
只要拿到这个配置，就可以导入别人的站点地图
选择器
直译过来就是一个选择器。要从一个充满数据的 HTML 页面中提取数据，需要一个选择器来定位我们数据的具体位置。
每个 Selector 可以获取一条数据。要获取多条数据，需要定位多个 Selector。
Web Scraper 提供的 Selector 有很多，但本文文章 只介绍几个使用最频繁、覆盖面最广的 Selector。了解一二之后，其他的原理都差不多。可以上手了。
Web Scraper 使用 CSS 选择器来定位元素。如果你不知道，没关系。在大多数场景下，您可以直接通过鼠标点击选择元素，Web Scraper 会自动解析相应的 CSS。小路。
Selector 可以嵌套，子 Selector 的 CSS 选择器作用域就是父 Selector。
正是这种无穷无尽的嵌套关系让我们能够递归地爬取整个 网站 数据。
下面是我们后面经常放的选择器拓扑，可以用来直观的展示Web Scraper的爬取逻辑
数据抓取和导出
定义站点地图规则后，单击“抓取”开始抓取数据。
爬取数据后，不会立即显示在页面上，需要再次手动点击刷新按钮才能看到数据。
最终数据也可以导出为 csv 或 xlsx 文件。
# 3. 寻呼机爬取
爬取数据最经典的模型是列表、分页和明细。接下来我也会围绕这个方向爬取CSDN博客文章来介绍几个Selector的用法。
寻呼机可以分为两种类型：
在早期版本的 web-scraper 中，两种爬取方式是不同的。
对于一些 网站 来说确实足够了，但有很大的局限性。
经过我的实验，使用Link选择器的第一个原理是在下一页取出a标签的超链接，然后访问它，但并不是所有网站的下一页都是通过a标签实现的.
如果用js监听事件然后像下面这样跳转，就不能使用Link选择器了。
在新版本的网络爬虫中，它提供了对导航分页器的特殊支持，并增加了一个分页选择器，可以完全适用于两种场景，我将在下面进行演示。
寻呼机爬行而不重新加载页面
点击具体的CSDN博文，拉到底部，就可以看到评论区了。
如果你的文章比较热门，有很多同学评论，CSDN会分页显示，但是不管在哪个页面评论都属于同一篇文章文章，你浏览的时候当你在任何页面的评论区时，博文不需要刷新，因为这个分页不会重新加载页面。
对于这种不需要重新加载页面的点击，可以使用Element Click来解决。
最后一点必须注意，要选择root和next_page，只有这样才能递归爬取
最终爬取效果如下
使用Element Click的站点地图配置如下，可以直接导入我的配置进行研究，下载配置文件：/iidSSugkch
当然，对于分页之类的东西，网页爬虫提供了更专业的分页选择器，配置更精简，效果最好。
对应sitemap的配置如下，可以直接导入使用。下载配置文件：/iidSSugkch
寻呼机爬行以重新加载页面
CSDN的博客文章列表，拉到底部，点击具体页面按钮，否则最右边的下一页会重新加载当前页面。
对于这种分页器，Element Click 什么都做不了，读者可以自行验证，最多爬一页就会关闭。
而且作为一个为分页而生的Pagination选择器，自然适用
爬取的拓扑同上，这里不再赘述。
对应sitemap的配置如下，可以直接导入学习，下载配置文件：/iidSSugkch
# 4. 次要页面的爬取
CSDN的博客列表列表页，显示的信息比较粗略，只有标题，发表时间，阅读量，评论数，是否是原创。
如果你想获得更多的信息，比如博文的文字、点赞数、采集数、评论区的内容，你必须点击具体的博文链接才能查看。
网络爬虫的操作逻辑与人类相同。如果你想抓取更详细的博文信息，你必须打开一个新的页面来获取它，而网络爬虫的链接选择器恰好做到了这一点。
爬取路径拓扑如下
爬取的效果如下
sitemap的配置如下，可以直接导入使用。下载配置文件：/iidSSugkch
# 5. 最后
以上整理了分页和二级页面的爬取方案，主要有：分页器爬取和二级页面爬取。
只要学会了这两个，就已经可以处理绝大多数结构化的网络数据了。
scrapy分页抓取网页(Scrapy高级Python爬虫框架 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 40 次浏览 • 2022-02-07 15:11
scrapy分页抓取网页(Scrapy高级Python爬虫框架
)
介绍
Scrapy 是一个高级的 Python 爬虫框架。它不仅收录爬虫功能，还可以方便地将爬虫数据保存为csv、json等文件。
首先我们安装 Scrapy。
它可用于数据挖掘、信息处理或存储历史数据等一系列程序中。它最初是为网页抓取（更准确地说，网页抓取）而设计的，但也可用于检索 API（例如 Amazon Associates Web 服务）或通用网络爬虫返回的数据。Scrapy 用途广泛，可用于数据挖掘、监控和自动化测试。
Scrapy 使用 Twisted 异步网络库来处理网络通信。整体结构大致如下
安装 linux 或 mac
pip3 install scrapy
视窗
#下载twisted
http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
#安装wheel模块之后才能安装.whl文件
pip3 install wheel
#安装twisted
pip install Twisted‑18.4.0‑cp36‑cp36m‑win_amd64.whl
pip3 install pywin32
#安装scrapy
pip3 install scrapy
使用创建项目
格式：scrapy startproject 项目名称
scrapy startproject spider
项目创建后会生成一个目录，如下：
项目名称/
- spiders # 爬虫文件
- chouti.py
- cnblgos.py
....
- items.py # 持久化
- pipelines # 持久化
- middlewares.py # 中间件
- settings.py # 配置文件（爬虫）
scrapy.cfg # 配置文件（部署）
创建爬虫
格式：
cd 项目名称
scrapy genspider 爬虫名称将被爬取 网站
cd spider
scrapy genspider chouti chouti.com
爬虫创建后会在spiders文件夹下生成一个文件
打开chouti.py后如下：
运行爬虫
scrapy crawl chouti
scrapy crawl chouti --nolog # 不打印日志
例子
# -*- coding: utf-8 -*-
import scrapy
class ChoutiSpider(scrapy.Spider):
'''
爬去抽屉网的帖子信息
'''
name = 'chouti'
allowed_domains = ['chouti.com']
start_urls = ['http://chouti.com/']
def parse(self, response):
# 获取帖子列表的父级div
content_div = response.xpath('//div[@id="content-list"]')
# 获取帖子item的列表
items_list = content_div.xpath('.//div[@class="item"]')
# 打开一个文件句柄，目的是为了将获取的东西写入文件
with open('articles.log','a+',encoding='utf-8') as f:
# 循环item_list
for item in items_list:
# 获取每个item的第一个a标签的文本和url链接
text = item.xpath('.//a/text()').extract_first()
href = item.xpath('.//a/@href').extract_first()
# print(href, text.strip())
# print('-'*100)
f.write(href+'\n')
f.write(text.strip()+'\n')
f.write('-'*100+'\n')
# 获取分页的页码，然后让程序循环爬去每个链接
# 页码标签对象列表
page_list = response.xpath('//div[@id="dig_lcpage"]')
# 循环列表
for page in page_list:
# 获取每个标签下的a标签的url，即每页的链接
page_a_url = page.xpath('.//a/@href').extract()
# 将域名和url拼接起来
page_url = 'https://dig.chouti.com' + page_a_url
# 重要的一步！！！！
# 导入Request模块，然后实例化一个Request对象，然后yield它
# 就会自动执行Request对象的callback方法，爬去的是url参数中的链接
from scrapy.http import Request
yield Request(url=page_url,callback=self.parse) 查看全部
)
介绍
Scrapy 是一个高级的 Python 爬虫框架。它不仅收录爬虫功能，还可以方便地将爬虫数据保存为csv、json等文件。
首先我们安装 Scrapy。
它可用于数据挖掘、信息处理或存储历史数据等一系列程序中。它最初是为网页抓取（更准确地说，网页抓取）而设计的，但也可用于检索 API（例如 Amazon Associates Web 服务）或通用网络爬虫返回的数据。Scrapy 用途广泛，可用于数据挖掘、监控和自动化测试。
Scrapy 使用 Twisted 异步网络库来处理网络通信。整体结构大致如下
安装 linux 或 mac
pip3 install scrapy
视窗
#下载twisted
http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
#安装wheel模块之后才能安装.whl文件
pip3 install wheel
#安装twisted
pip install Twisted‑18.4.0‑cp36‑cp36m‑win_amd64.whl
pip3 install pywin32
#安装scrapy
pip3 install scrapy
使用创建项目
格式：scrapy startproject 项目名称
scrapy startproject spider
项目创建后会生成一个目录，如下：
项目名称/
- spiders # 爬虫文件
- chouti.py
- cnblgos.py
....
- items.py # 持久化
- pipelines # 持久化
- middlewares.py # 中间件
- settings.py # 配置文件（爬虫）
scrapy.cfg # 配置文件（部署）
创建爬虫
格式：
cd 项目名称
scrapy genspider 爬虫名称将被爬取 网站
cd spider
scrapy genspider chouti chouti.com
爬虫创建后会在spiders文件夹下生成一个文件
打开chouti.py后如下：
运行爬虫
scrapy crawl chouti
scrapy crawl chouti --nolog # 不打印日志
例子
# -*- coding: utf-8 -*-
import scrapy
class ChoutiSpider(scrapy.Spider):
'''
爬去抽屉网的帖子信息
'''
name = 'chouti'
allowed_domains = ['chouti.com']
start_urls = ['http://chouti.com/']
def parse(self, response):
# 获取帖子列表的父级div
content_div = response.xpath('//div[@id="content-list"]')
# 获取帖子item的列表
items_list = content_div.xpath('.//div[@class="item"]')
# 打开一个文件句柄，目的是为了将获取的东西写入文件
with open('articles.log','a+',encoding='utf-8') as f:
# 循环item_list
for item in items_list:
# 获取每个item的第一个a标签的文本和url链接
text = item.xpath('.//a/text()').extract_first()
href = item.xpath('.//a/@href').extract_first()
# print(href, text.strip())
# print('-'*100)
f.write(href+'\n')
f.write(text.strip()+'\n')
f.write('-'*100+'\n')
# 获取分页的页码，然后让程序循环爬去每个链接
# 页码标签对象列表
page_list = response.xpath('//div[@id="dig_lcpage"]')
# 循环列表
for page in page_list:
# 获取每个标签下的a标签的url，即每页的链接
page_a_url = page.xpath('.//a/@href').extract()
# 将域名和url拼接起来
page_url = 'https://dig.chouti.com' + page_a_url
# 重要的一步！！！！
# 导入Request模块，然后实例化一个Request对象，然后yield它
# 就会自动执行Request对象的callback方法，爬去的是url参数中的链接
from scrapy.http import Request
yield Request(url=page_url,callback=self.parse) 查看全部
scrapy分页抓取网页(Scrapy高级Python爬虫框架
)
介绍
Scrapy 是一个高级的 Python 爬虫框架。它不仅收录爬虫功能，还可以方便地将爬虫数据保存为csv、json等文件。
首先我们安装 Scrapy。
它可用于数据挖掘、信息处理或存储历史数据等一系列程序中。它最初是为网页抓取（更准确地说，网页抓取）而设计的，但也可用于检索 API（例如 Amazon Associates Web 服务）或通用网络爬虫返回的数据。Scrapy 用途广泛，可用于数据挖掘、监控和自动化测试。
Scrapy 使用 Twisted 异步网络库来处理网络通信。整体结构大致如下
安装 linux 或 mac
pip3 install scrapy
视窗
#下载twisted
http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
#安装wheel模块之后才能安装.whl文件
pip3 install wheel
#安装twisted
pip install Twisted‑18.4.0‑cp36‑cp36m‑win_amd64.whl
pip3 install pywin32
#安装scrapy
pip3 install scrapy
使用创建项目
格式：scrapy startproject 项目名称
scrapy startproject spider
项目创建后会生成一个目录，如下：
项目名称/
- spiders # 爬虫文件
- chouti.py
- cnblgos.py
....
- items.py # 持久化
- pipelines # 持久化
- middlewares.py # 中间件
- settings.py # 配置文件（爬虫）
scrapy.cfg # 配置文件（部署）
创建爬虫
格式：
cd 项目名称
scrapy genspider 爬虫名称将被爬取 网站
cd spider
scrapy genspider chouti chouti.com
爬虫创建后会在spiders文件夹下生成一个文件
打开chouti.py后如下：
运行爬虫
scrapy crawl chouti
scrapy crawl chouti --nolog # 不打印日志
例子
# -*- coding: utf-8 -*-
import scrapy
class ChoutiSpider(scrapy.Spider):
'''
爬去抽屉网的帖子信息
'''
name = 'chouti'
allowed_domains = ['chouti.com']
start_urls = ['http://chouti.com/']
def parse(self, response):
# 获取帖子列表的父级div
content_div = response.xpath('//div[@id="content-list"]')
# 获取帖子item的列表
items_list = content_div.xpath('.//div[@class="item"]')
# 打开一个文件句柄，目的是为了将获取的东西写入文件
with open('articles.log','a+',encoding='utf-8') as f:
# 循环item_list
for item in items_list:
# 获取每个item的第一个a标签的文本和url链接
text = item.xpath('.//a/text()').extract_first()
href = item.xpath('.//a/@href').extract_first()
# print(href, text.strip())
# print('-'*100)
f.write(href+'\n')
f.write(text.strip()+'\n')
f.write('-'*100+'\n')
# 获取分页的页码，然后让程序循环爬去每个链接
# 页码标签对象列表
page_list = response.xpath('//div[@id="dig_lcpage"]')
# 循环列表
for page in page_list:
# 获取每个标签下的a标签的url，即每页的链接
page_a_url = page.xpath('.//a/@href').extract()
# 将域名和url拼接起来
page_url = 'https://dig.chouti.com' + page_a_url
# 重要的一步！！！！
# 导入Request模块，然后实例化一个Request对象，然后yield它
# 就会自动执行Request对象的callback方法，爬去的是url参数中的链接
from scrapy.http import Request
yield Request(url=page_url,callback=self.parse)
scrapy分页抓取网页(Python大火，为了跟上时代，试着自学了下某位作者)
网站优化 • 优采云 发表了文章 • 0 个评论 • 51 次浏览 • 2022-02-07 12:20
scrapy分页抓取网页(Python大火，为了跟上时代，试着自学了下某位作者)
Python 最近火了一把。为了跟上时代的步伐，我试着自学。Scrapy 是一个高级的 Python 爬虫框架，不仅收录爬虫功能，还可以方便地将爬虫数据保存为 csv、json 等文件。
今天我们将尝试使用Scrapy爬取简书某作者的所有文章。
在本教程中，我们假设您已经安装了 Scrapy。如果没有，请参考。
1.创建项目
在开始爬取之前，我们必须新建一个 Scrapy 项目，我这里命名为 jianshu_article。打开 Mac 终端，cd 到您要存储代码的目录，然后运行以下命令：
//Mac终端运行如下命令：
scrapy startproject jianshu_article
2.创建爬虫
//cd到上面创建的文件目录
cd jianshu_article
//创建爬虫程序
scrapy genspider jianshu jianshu.com
/*
文件说明：
scrapy.cfg 项目的配置信息，主要为Scrapy命令行工具提供一个基础的配置信息。（真正爬虫相关的配置信息在settings.py文件中）
items.py 设置数据存储模型，用于结构化数据，如：Django的Model
pipelines 数据处理行为，如：一般结构化的数据持久化
settings.py 配置文件，如：USER_AGENT(模拟浏览器，应对网站反爬)，递归的层数、并发数，延迟下载等
spiders 爬虫目录，如：创建文件，编写爬虫规则
*/
为了方便编写程序，我们使用Pycharm打开项目。执行上述命令后，程序会自动创建目录和文件，这会生成一个 jianshu.py 文件，后面我们的主要逻辑会写在这个文件中。
简书.py
3.设置数据模型
双击 items.py 文件。
找到你要爬取的作者主页，比如我自己的主页，用谷歌浏览器打开，在空白处右键，点击“勾选”进入控制台开发者模式：
打开控制台.png
通过分析网页的源代码，我们大概需要以下内容：
# -*- coding: utf-8 -*-
# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html
import scrapy
class JianshuArticalItem(scrapy.Item):
avatar = scrapy.Field() #头像
nickname = scrapy.Field() #昵称
time = scrapy.Field() #发表时间
wrap_img = scrapy.Field() #封面（缺省值）
title = scrapy.Field() #标题
abstract = scrapy.Field() #正文部分显示
read = scrapy.Field() #查看人数
comments = scrapy.Field() #评论数
like = scrapy.Field() #喜欢（点赞）
detail = scrapy.Field() #文章详情url
pass
这样，数据模型就创建好了，以后我运行爬虫的时候，我得到的数据会存放在模型对应的位置。
4.分析网页源码，编写爬虫
因为我比较懒，很少写文章，而且文章的数量比较少，为了显示分页的效果，我选择了作者CC老师_MissCC的主页在简书爬取。
我们可以通过分析 URL 找到一些特征：
作者的网址是：+作者ID：
作者主页 URL.png
文章 的 URL 为：+ 文章ID：
文章网址.png
虽然我们直接在浏览器中打开作者的 URL，但是用鼠标滚轮向下滚动会动态加载下一页，直到最后一个 文章URL 保持不变。但是作为一个Scrapy爬虫，好像只能拿到首页，那怎么办呢？根据我个人多年的开发经验，尝试在URL后面拼接一个“page”参数加上页数。果然，我可以请求不同的数据。
拼接参数页面获取分页数据.png
找到这些规则，我们可以通过分析HTML源代码得到我们想要的数据。
首先，我们回到 jianshu.py 文件，导入模型：
//从项目名 jianshu_article的文件items.py导入JianshuArticleItem类
from jianshu_article.items import JianshuArticleItem
设置必要的参数以启动第一个请求：
# -*- coding: utf-8 -*-
import scrapy
from jianshu_article.items import JianshuArticleItem
class JianshuSpider(scrapy.Spider):
name = 'jianshu'
allowed_domains = ['jianshu.com']
user_id = "1b4c832fb2ca"
url = "https://www.jianshu.com/u/{0}?page=1".format(user_id)
start_urls = [
url,
]
def parse(self, response):
#用户头像
c = response.xpath('//div[@class="main-top"]/a[@class="avatar"]/img/@src').extract_first()
print(c)
pass
此时终端运行命令scrapy crawl jianshu，理论上可以打印网页内容。其实并没有请求数据，终端会打印一些日志信息：
日志.png
不难发现，403问题和HTTP状态码未处理或不允许问题导致“Closing spider (finished)”爬虫终止。通过万能的百度知道，大概是网站采取了一些相应的防爬虫措施造成的。对症下药，我们只需要在settings.py中做一些相应的修改：
```
User_Agent中文名为用户代理，简称 UA，它是一个特殊字符串头，使得服务器能够识别客户使用的
操作系统及版本、CPU 类型、浏览器及版本、浏览器渲染引擎、浏览器语言、浏览器插件等。
通俗点讲，我们配置这个字段的目的就是为了伪装成浏览器打开网页，达到骗过目标网站的监测。
```
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.186 Safari/537.36'
CONCURRENT_REQUESTS = 1 #并发数
DOWNLOAD_DELAY = 5 #为了防止IP被封，我们5秒请求一次
HTTPERROR_ALLOWED_CODES = [403] #上面报的是403，就把403加入
#默认为True，就是要遵守robots.txt 的规则，这里我们改为False
ROBOTSTXT_OBEY = False
进行相应修改后，我们再次执行爬虫命令：scrapy crawl jianshu，查看日志打印获取头像。
获取头像.png
既然可以成功爬取网页数据，那么我们后面要做的就是分析网页的源代码。当然，在这之前你得对xpath有一定的了解。
以下是对Scrapy中文官网的介绍：
有很多方法可以从网页中提取数据。Scrapy 使用基于 XPath 和 CSS 表达式的机制：. 有关选择器和其他提取机制的信息，请参见此处。
以下是 XPath 表达式及其对应含义的示例：
以上只是几个简单的 XPath 示例，XPath 实际上远比这强大。如果您想了解更多信息，我们推荐此 XPath 教程。
通过上面的介绍，相信你可以做好接下来的爬虫工作了，把jianshu.py的所有代码贴在下面，供参考：
# -*- coding: utf-8 -*-
import scrapy
from jianshu_article.items import JianshuArticleItem
class JianshuSpider(scrapy.Spider):
name = 'jianshu'
allowed_domains = ['jianshu.com']
user_id = "1b4c832fb2ca" #替换此用户ID可获取你需要的数据，或者放开下一行的注释
#user_id = input('请输入作者id：\n')
url = "https://www.jianshu.com/u/{0}?page=1".format(user_id)
start_urls = [
url,
]
def parse(self, response):
# [关注,粉丝,文章]
a = response.xpath('//div[@class="main-top"]/div[@class="info"]/ul/li/div/a/p/text()').extract()
print(a)
# [字数,收获喜欢]
b = response.xpath('//div[@class="main-top"]/div[@class="info"]/ul/li/div/p/text()').extract()
print(b)
# 大头像
c = response.xpath('//div[@class="main-top"]/a[@class="avatar"]/img/@src').extract_first()
print(c)
# 用户名
d = response.xpath('//div[@class="main-top"]/div[@class="title"]/a/text()').extract_first()
print(d)
# 性别
e = response.xpath('//div[@class="main-top"]/div[@class="title"]/i/@class').extract_first()
print(e)
# 获取文章总数，计算页数。（简书网站默认每页是9组数据）
temp = int(a[2])
if (temp % 9 > 0):
count = temp // 9 + 1
else:
count = temp // 9
print("总共" + str(count) + "页")
base_url = "https://www.jianshu.com/u/{0}?page={1}"
for i in range(1, count + 1):
i = count + 1 - i #理论上正序1~count就是按顺序获取的，但是获取的数据是倒置的，所以我们获取count~1的数据，得到的数组就是按照网页形式1~count页码排序的了
yield scrapy.Request(base_url.format(self.user_id, i), dont_filter=True, callback=self.parse_page)
#迭代返回每页的内容
def parse_page(self, response):
for sel in response.xpath('//div[@id="list-container"]/ul/li'):
item = JianshuArticleItem()
item['wrap_img'] = sel.xpath('a/img/@src').extract_first()
item['avatar'] = sel.xpath('div//a[@class="avatar"]/img/@src').extract_first()
item['nickname'] = sel.xpath('div//a[@class="nickname"]/text()').extract_first()
item['time'] = sel.xpath('div//span[@class="time"]/@data-shared-at').extract_first()
item['title'] = sel.xpath('div/a[@class="title"]/text()').extract_first()
item['abstract'] = sel.xpath('div/p[@class="abstract"]/text()').extract_first()
item['read'] = sel.xpath('div/div[@class="meta"]/a[1]/text()').extract()[1]
item['comments'] = sel.xpath('div/div[@class="meta"]/a[2]/text()').extract()[1]
item['like'] = sel.xpath('div/div[@class="meta"]/span/text()').extract_first()
item['detail'] = sel.xpath('div/a[@class="title"]/@href').extract_first()
yield item
至此，爬虫代码就写好了。如果要保存获取的数据，可以在终端执行以下命令：
/*
此命令用于把爬取的数据保存为json文件格式，当然你也可以保存为别的文件格式。
Scrapy官方列出的文件格式有如下几种：('json', 'jsonlines', 'jl', 'csv', 'xml', 'marshal', 'pickle')。
温馨提示：如果要再次爬取，最好换一个文件名或者清空数据再爬取，因为第二还是写入上一个文件，数据不会覆盖，
会堆积在上次获取的下面，造成json文件格式报错。
*/
scrapy crawl jianshu -o data.json
程序执行后，我们可以在文件目录下看到新生成的data.json文件，双击可以看到我们想要获取的所有数据：
执行crawler.png获取的数据
json解析数据和网站.png上的一模一样
github地址： 查看全部
Python 最近火了一把。为了跟上时代的步伐，我试着自学。Scrapy 是一个高级的 Python 爬虫框架，不仅收录爬虫功能，还可以方便地将爬虫数据保存为 csv、json 等文件。
今天我们将尝试使用Scrapy爬取简书某作者的所有文章。
在本教程中，我们假设您已经安装了 Scrapy。如果没有，请参考。
1.创建项目
在开始爬取之前，我们必须新建一个 Scrapy 项目，我这里命名为 jianshu_article。打开 Mac 终端，cd 到您要存储代码的目录，然后运行以下命令：
//Mac终端运行如下命令：
scrapy startproject jianshu_article
2.创建爬虫
//cd到上面创建的文件目录
cd jianshu_article
//创建爬虫程序
scrapy genspider jianshu jianshu.com
/*
文件说明：
scrapy.cfg 项目的配置信息，主要为Scrapy命令行工具提供一个基础的配置信息。（真正爬虫相关的配置信息在settings.py文件中）
items.py 设置数据存储模型，用于结构化数据，如：Django的Model
pipelines 数据处理行为，如：一般结构化的数据持久化
settings.py 配置文件，如：USER_AGENT(模拟浏览器，应对网站反爬)，递归的层数、并发数，延迟下载等
spiders 爬虫目录，如：创建文件，编写爬虫规则
*/
为了方便编写程序，我们使用Pycharm打开项目。执行上述命令后，程序会自动创建目录和文件，这会生成一个 jianshu.py 文件，后面我们的主要逻辑会写在这个文件中。
简书.py
3.设置数据模型
双击 items.py 文件。
找到你要爬取的作者主页，比如我自己的主页，用谷歌浏览器打开，在空白处右键，点击“勾选”进入控制台开发者模式：
打开控制台.png
通过分析网页的源代码，我们大概需要以下内容：
# -*- coding: utf-8 -*-
# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html
import scrapy
class JianshuArticalItem(scrapy.Item):
avatar = scrapy.Field() #头像
nickname = scrapy.Field() #昵称
time = scrapy.Field() #发表时间
wrap_img = scrapy.Field() #封面（缺省值）
title = scrapy.Field() #标题
abstract = scrapy.Field() #正文部分显示
read = scrapy.Field() #查看人数
comments = scrapy.Field() #评论数
like = scrapy.Field() #喜欢（点赞）
detail = scrapy.Field() #文章详情url
pass
这样，数据模型就创建好了，以后我运行爬虫的时候，我得到的数据会存放在模型对应的位置。
4.分析网页源码，编写爬虫
因为我比较懒，很少写文章，而且文章的数量比较少，为了显示分页的效果，我选择了作者CC老师_MissCC的主页在简书爬取。
我们可以通过分析 URL 找到一些特征：
作者的网址是：+作者ID：
作者主页 URL.png
文章 的 URL 为：+ 文章ID：
文章网址.png
虽然我们直接在浏览器中打开作者的 URL，但是用鼠标滚轮向下滚动会动态加载下一页，直到最后一个 文章URL 保持不变。但是作为一个Scrapy爬虫，好像只能拿到首页，那怎么办呢？根据我个人多年的开发经验，尝试在URL后面拼接一个“page”参数加上页数。果然，我可以请求不同的数据。
拼接参数页面获取分页数据.png
找到这些规则，我们可以通过分析HTML源代码得到我们想要的数据。
首先，我们回到 jianshu.py 文件，导入模型：
//从项目名 jianshu_article的文件items.py导入JianshuArticleItem类
from jianshu_article.items import JianshuArticleItem
设置必要的参数以启动第一个请求：
# -*- coding: utf-8 -*-
import scrapy
from jianshu_article.items import JianshuArticleItem
class JianshuSpider(scrapy.Spider):
name = 'jianshu'
allowed_domains = ['jianshu.com']
user_id = "1b4c832fb2ca"
url = "https://www.jianshu.com/u/{0}?page=1".format(user_id)
start_urls = [
url,
]
def parse(self, response):
#用户头像
c = response.xpath('//div[@class="main-top"]/a[@class="avatar"]/img/@src').extract_first()
print(c)
pass
此时终端运行命令scrapy crawl jianshu，理论上可以打印网页内容。其实并没有请求数据，终端会打印一些日志信息：
日志.png
不难发现，403问题和HTTP状态码未处理或不允许问题导致“Closing spider (finished)”爬虫终止。通过万能的百度知道，大概是网站采取了一些相应的防爬虫措施造成的。对症下药，我们只需要在settings.py中做一些相应的修改：
```
User_Agent中文名为用户代理，简称 UA，它是一个特殊字符串头，使得服务器能够识别客户使用的
操作系统及版本、CPU 类型、浏览器及版本、浏览器渲染引擎、浏览器语言、浏览器插件等。
通俗点讲，我们配置这个字段的目的就是为了伪装成浏览器打开网页，达到骗过目标网站的监测。
```
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.186 Safari/537.36'
CONCURRENT_REQUESTS = 1 #并发数
DOWNLOAD_DELAY = 5 #为了防止IP被封，我们5秒请求一次
HTTPERROR_ALLOWED_CODES = [403] #上面报的是403，就把403加入
#默认为True，就是要遵守robots.txt 的规则，这里我们改为False
ROBOTSTXT_OBEY = False
进行相应修改后，我们再次执行爬虫命令：scrapy crawl jianshu，查看日志打印获取头像。
获取头像.png
既然可以成功爬取网页数据，那么我们后面要做的就是分析网页的源代码。当然，在这之前你得对xpath有一定的了解。
以下是对Scrapy中文官网的介绍：
有很多方法可以从网页中提取数据。Scrapy 使用基于 XPath 和 CSS 表达式的机制：. 有关选择器和其他提取机制的信息，请参见此处。
以下是 XPath 表达式及其对应含义的示例：
以上只是几个简单的 XPath 示例，XPath 实际上远比这强大。如果您想了解更多信息，我们推荐此 XPath 教程。
通过上面的介绍，相信你可以做好接下来的爬虫工作了，把jianshu.py的所有代码贴在下面，供参考：
# -*- coding: utf-8 -*-
import scrapy
from jianshu_article.items import JianshuArticleItem
class JianshuSpider(scrapy.Spider):
name = 'jianshu'
allowed_domains = ['jianshu.com']
user_id = "1b4c832fb2ca" #替换此用户ID可获取你需要的数据，或者放开下一行的注释
#user_id = input('请输入作者id：\n')
url = "https://www.jianshu.com/u/{0}?page=1".format(user_id)
start_urls = [
url,
]
def parse(self, response):
# [关注,粉丝,文章]
a = response.xpath('//div[@class="main-top"]/div[@class="info"]/ul/li/div/a/p/text()').extract()
print(a)
# [字数,收获喜欢]
b = response.xpath('//div[@class="main-top"]/div[@class="info"]/ul/li/div/p/text()').extract()
print(b)
# 大头像
c = response.xpath('//div[@class="main-top"]/a[@class="avatar"]/img/@src').extract_first()
print(c)
# 用户名
d = response.xpath('//div[@class="main-top"]/div[@class="title"]/a/text()').extract_first()
print(d)
# 性别
e = response.xpath('//div[@class="main-top"]/div[@class="title"]/i/@class').extract_first()
print(e)
# 获取文章总数，计算页数。（简书网站默认每页是9组数据）
temp = int(a[2])
if (temp % 9 > 0):
count = temp // 9 + 1
else:
count = temp // 9
print("总共" + str(count) + "页")
base_url = "https://www.jianshu.com/u/{0}?page={1}"
for i in range(1, count + 1):
i = count + 1 - i #理论上正序1~count就是按顺序获取的，但是获取的数据是倒置的，所以我们获取count~1的数据，得到的数组就是按照网页形式1~count页码排序的了
yield scrapy.Request(base_url.format(self.user_id, i), dont_filter=True, callback=self.parse_page)
#迭代返回每页的内容
def parse_page(self, response):
for sel in response.xpath('//div[@id="list-container"]/ul/li'):
item = JianshuArticleItem()
item['wrap_img'] = sel.xpath('a/img/@src').extract_first()
item['avatar'] = sel.xpath('div//a[@class="avatar"]/img/@src').extract_first()
item['nickname'] = sel.xpath('div//a[@class="nickname"]/text()').extract_first()
item['time'] = sel.xpath('div//span[@class="time"]/@data-shared-at').extract_first()
item['title'] = sel.xpath('div/a[@class="title"]/text()').extract_first()
item['abstract'] = sel.xpath('div/p[@class="abstract"]/text()').extract_first()
item['read'] = sel.xpath('div/div[@class="meta"]/a[1]/text()').extract()[1]
item['comments'] = sel.xpath('div/div[@class="meta"]/a[2]/text()').extract()[1]
item['like'] = sel.xpath('div/div[@class="meta"]/span/text()').extract_first()
item['detail'] = sel.xpath('div/a[@class="title"]/@href').extract_first()
yield item
至此，爬虫代码就写好了。如果要保存获取的数据，可以在终端执行以下命令：
/*
此命令用于把爬取的数据保存为json文件格式，当然你也可以保存为别的文件格式。
Scrapy官方列出的文件格式有如下几种：('json', 'jsonlines', 'jl', 'csv', 'xml', 'marshal', 'pickle')。
温馨提示：如果要再次爬取，最好换一个文件名或者清空数据再爬取，因为第二还是写入上一个文件，数据不会覆盖，
会堆积在上次获取的下面，造成json文件格式报错。
*/
scrapy crawl jianshu -o data.json
程序执行后，我们可以在文件目录下看到新生成的data.json文件，双击可以看到我们想要获取的所有数据：
执行crawler.png获取的数据
json解析数据和网站.png上的一模一样
github地址： 查看全部
scrapy分页抓取网页(Python大火，为了跟上时代，试着自学了下某位作者)
Python 最近火了一把。为了跟上时代的步伐，我试着自学。Scrapy 是一个高级的 Python 爬虫框架，不仅收录爬虫功能，还可以方便地将爬虫数据保存为 csv、json 等文件。
今天我们将尝试使用Scrapy爬取简书某作者的所有文章。
在本教程中，我们假设您已经安装了 Scrapy。如果没有，请参考。
1.创建项目
在开始爬取之前，我们必须新建一个 Scrapy 项目，我这里命名为 jianshu_article。打开 Mac 终端，cd 到您要存储代码的目录，然后运行以下命令：
//Mac终端运行如下命令：
scrapy startproject jianshu_article
2.创建爬虫
//cd到上面创建的文件目录
cd jianshu_article
//创建爬虫程序
scrapy genspider jianshu jianshu.com
/*
文件说明：
scrapy.cfg 项目的配置信息，主要为Scrapy命令行工具提供一个基础的配置信息。（真正爬虫相关的配置信息在settings.py文件中）
items.py 设置数据存储模型，用于结构化数据，如：Django的Model
pipelines 数据处理行为，如：一般结构化的数据持久化
settings.py 配置文件，如：USER_AGENT(模拟浏览器，应对网站反爬)，递归的层数、并发数，延迟下载等
spiders 爬虫目录，如：创建文件，编写爬虫规则
*/
为了方便编写程序，我们使用Pycharm打开项目。执行上述命令后，程序会自动创建目录和文件，这会生成一个 jianshu.py 文件，后面我们的主要逻辑会写在这个文件中。
简书.py
3.设置数据模型
双击 items.py 文件。
找到你要爬取的作者主页，比如我自己的主页，用谷歌浏览器打开，在空白处右键，点击“勾选”进入控制台开发者模式：
打开控制台.png
通过分析网页的源代码，我们大概需要以下内容：
# -*- coding: utf-8 -*-
# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html
import scrapy
class JianshuArticalItem(scrapy.Item):
avatar = scrapy.Field() #头像
nickname = scrapy.Field() #昵称
time = scrapy.Field() #发表时间
wrap_img = scrapy.Field() #封面（缺省值）
title = scrapy.Field() #标题
abstract = scrapy.Field() #正文部分显示
read = scrapy.Field() #查看人数
comments = scrapy.Field() #评论数
like = scrapy.Field() #喜欢（点赞）
detail = scrapy.Field() #文章详情url
pass
这样，数据模型就创建好了，以后我运行爬虫的时候，我得到的数据会存放在模型对应的位置。
4.分析网页源码，编写爬虫
因为我比较懒，很少写文章，而且文章的数量比较少，为了显示分页的效果，我选择了作者CC老师_MissCC的主页在简书爬取。
我们可以通过分析 URL 找到一些特征：
作者的网址是：+作者ID：
作者主页 URL.png
文章 的 URL 为：+ 文章ID：
文章网址.png
虽然我们直接在浏览器中打开作者的 URL，但是用鼠标滚轮向下滚动会动态加载下一页，直到最后一个 文章URL 保持不变。但是作为一个Scrapy爬虫，好像只能拿到首页，那怎么办呢？根据我个人多年的开发经验，尝试在URL后面拼接一个“page”参数加上页数。果然，我可以请求不同的数据。
拼接参数页面获取分页数据.png
找到这些规则，我们可以通过分析HTML源代码得到我们想要的数据。
首先，我们回到 jianshu.py 文件，导入模型：
//从项目名 jianshu_article的文件items.py导入JianshuArticleItem类
from jianshu_article.items import JianshuArticleItem
设置必要的参数以启动第一个请求：
# -*- coding: utf-8 -*-
import scrapy
from jianshu_article.items import JianshuArticleItem
class JianshuSpider(scrapy.Spider):
name = 'jianshu'
allowed_domains = ['jianshu.com']
user_id = "1b4c832fb2ca"
url = "https://www.jianshu.com/u/{0}?page=1".format(user_id)
start_urls = [
url,
]
def parse(self, response):
#用户头像
c = response.xpath('//div[@class="main-top"]/a[@class="avatar"]/img/@src').extract_first()
print(c)
pass
此时终端运行命令scrapy crawl jianshu，理论上可以打印网页内容。其实并没有请求数据，终端会打印一些日志信息：
日志.png
不难发现，403问题和HTTP状态码未处理或不允许问题导致“Closing spider (finished)”爬虫终止。通过万能的百度知道，大概是网站采取了一些相应的防爬虫措施造成的。对症下药，我们只需要在settings.py中做一些相应的修改：
```
User_Agent中文名为用户代理，简称 UA，它是一个特殊字符串头，使得服务器能够识别客户使用的
操作系统及版本、CPU 类型、浏览器及版本、浏览器渲染引擎、浏览器语言、浏览器插件等。
通俗点讲，我们配置这个字段的目的就是为了伪装成浏览器打开网页，达到骗过目标网站的监测。
```
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.186 Safari/537.36'
CONCURRENT_REQUESTS = 1 #并发数
DOWNLOAD_DELAY = 5 #为了防止IP被封，我们5秒请求一次
HTTPERROR_ALLOWED_CODES = [403] #上面报的是403，就把403加入
#默认为True，就是要遵守robots.txt 的规则，这里我们改为False
ROBOTSTXT_OBEY = False
进行相应修改后，我们再次执行爬虫命令：scrapy crawl jianshu，查看日志打印获取头像。
获取头像.png
既然可以成功爬取网页数据，那么我们后面要做的就是分析网页的源代码。当然，在这之前你得对xpath有一定的了解。
以下是对Scrapy中文官网的介绍：
有很多方法可以从网页中提取数据。Scrapy 使用基于 XPath 和 CSS 表达式的机制：. 有关选择器和其他提取机制的信息，请参见此处。
以下是 XPath 表达式及其对应含义的示例：
以上只是几个简单的 XPath 示例，XPath 实际上远比这强大。如果您想了解更多信息，我们推荐此 XPath 教程。
通过上面的介绍，相信你可以做好接下来的爬虫工作了，把jianshu.py的所有代码贴在下面，供参考：
# -*- coding: utf-8 -*-
import scrapy
from jianshu_article.items import JianshuArticleItem
class JianshuSpider(scrapy.Spider):
name = 'jianshu'
allowed_domains = ['jianshu.com']
user_id = "1b4c832fb2ca" #替换此用户ID可获取你需要的数据，或者放开下一行的注释
#user_id = input('请输入作者id：\n')
url = "https://www.jianshu.com/u/{0}?page=1".format(user_id)
start_urls = [
url,
]
def parse(self, response):
# [关注,粉丝,文章]
a = response.xpath('//div[@class="main-top"]/div[@class="info"]/ul/li/div/a/p/text()').extract()
print(a)
# [字数,收获喜欢]
b = response.xpath('//div[@class="main-top"]/div[@class="info"]/ul/li/div/p/text()').extract()
print(b)
# 大头像
c = response.xpath('//div[@class="main-top"]/a[@class="avatar"]/img/@src').extract_first()
print(c)
# 用户名
d = response.xpath('//div[@class="main-top"]/div[@class="title"]/a/text()').extract_first()
print(d)
# 性别
e = response.xpath('//div[@class="main-top"]/div[@class="title"]/i/@class').extract_first()
print(e)
# 获取文章总数，计算页数。（简书网站默认每页是9组数据）
temp = int(a[2])
if (temp % 9 > 0):
count = temp // 9 + 1
else:
count = temp // 9
print("总共" + str(count) + "页")
base_url = "https://www.jianshu.com/u/{0}?page={1}"
for i in range(1, count + 1):
i = count + 1 - i #理论上正序1~count就是按顺序获取的，但是获取的数据是倒置的，所以我们获取count~1的数据，得到的数组就是按照网页形式1~count页码排序的了
yield scrapy.Request(base_url.format(self.user_id, i), dont_filter=True, callback=self.parse_page)
#迭代返回每页的内容
def parse_page(self, response):
for sel in response.xpath('//div[@id="list-container"]/ul/li'):
item = JianshuArticleItem()
item['wrap_img'] = sel.xpath('a/img/@src').extract_first()
item['avatar'] = sel.xpath('div//a[@class="avatar"]/img/@src').extract_first()
item['nickname'] = sel.xpath('div//a[@class="nickname"]/text()').extract_first()
item['time'] = sel.xpath('div//span[@class="time"]/@data-shared-at').extract_first()
item['title'] = sel.xpath('div/a[@class="title"]/text()').extract_first()
item['abstract'] = sel.xpath('div/p[@class="abstract"]/text()').extract_first()
item['read'] = sel.xpath('div/div[@class="meta"]/a[1]/text()').extract()[1]
item['comments'] = sel.xpath('div/div[@class="meta"]/a[2]/text()').extract()[1]
item['like'] = sel.xpath('div/div[@class="meta"]/span/text()').extract_first()
item['detail'] = sel.xpath('div/a[@class="title"]/@href').extract_first()
yield item
至此，爬虫代码就写好了。如果要保存获取的数据，可以在终端执行以下命令：
/*
此命令用于把爬取的数据保存为json文件格式，当然你也可以保存为别的文件格式。
Scrapy官方列出的文件格式有如下几种：('json', 'jsonlines', 'jl', 'csv', 'xml', 'marshal', 'pickle')。
温馨提示：如果要再次爬取，最好换一个文件名或者清空数据再爬取，因为第二还是写入上一个文件，数据不会覆盖，
会堆积在上次获取的下面，造成json文件格式报错。
*/
scrapy crawl jianshu -o data.json
程序执行后，我们可以在文件目录下看到新生成的data.json文件，双击可以看到我们想要获取的所有数据：
执行crawler.png获取的数据
json解析数据和网站.png上的一模一样
github地址：
scrapy分页抓取网页(如何抓取目标网站是以Js的方式动态生成数据的网页)
网站优化 • 优采云 发表了文章 • 0 个评论 • 55 次浏览 • 2022-02-07 12:14
scrapy分页抓取网页(如何抓取目标网站是以Js的方式动态生成数据的网页)
我们在爬取数据的时候，如果目标网站是以Js的方式动态生成数据，以滚动页面的方式进行分页，那我们怎么爬取呢？
如今日头条网站：
我们可以使用 Selenium 来做到这一点。虽然 Selenium 是为 Web 应用程序的自动化测试而设计的，但它非常适合数据抓取，并且可以轻松绕过 网站 的反爬虫限制，因为 Selenium 直接在浏览器中运行，就像真正的用户一样.
使用Selenium，我们不仅可以爬取Js动态生成数据的网页，还可以爬取通过滚动页面进行分页的网页。
首先，我们使用maven来导入Selenium依赖：
org.seleniumhq.selenium
selenium-java
2.47.1
然后就可以编写代码进行爬取了：
<p>import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import java.util.List;
import java.util.Random;
/**
* 如何抓取Js动态生成数据且以滚动页面方式分页的网页
* 以抓取今日头条为例说明：http://toutiao.com/
* Created by ysc on 10/13/15.
*/
public class Toutiao {
public static void main(String[] args) throws Exception{
//等待数据加载的时间
//为了防止服务器封锁，这里的时间要模拟人的行为，随机且不能太短
long waitLoadBaseTime = 3000;
int waitLoadRandomTime = 3000;
Random random = new Random(System.currentTimeMillis());
//火狐浏览器
WebDriver driver = new FirefoxDriver();
//要抓取的网页
driver.get("http://toutiao.com/");
//等待页面动态加载完毕
Thread.sleep(waitLoadBaseTime+random.nextInt(waitLoadRandomTime));
//要加载多少页数据
int pages=5;
for(int i=0; i 查看全部
我们在爬取数据的时候，如果目标网站是以Js的方式动态生成数据，以滚动页面的方式进行分页，那我们怎么爬取呢？
如今日头条网站：
我们可以使用 Selenium 来做到这一点。虽然 Selenium 是为 Web 应用程序的自动化测试而设计的，但它非常适合数据抓取，并且可以轻松绕过 网站 的反爬虫限制，因为 Selenium 直接在浏览器中运行，就像真正的用户一样.
使用Selenium，我们不仅可以爬取Js动态生成数据的网页，还可以爬取通过滚动页面进行分页的网页。
首先，我们使用maven来导入Selenium依赖：
org.seleniumhq.selenium
selenium-java
2.47.1
然后就可以编写代码进行爬取了：
<p>import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import java.util.List;
import java.util.Random;
/**
* 如何抓取Js动态生成数据且以滚动页面方式分页的网页
* 以抓取今日头条为例说明：http://toutiao.com/
* Created by ysc on 10/13/15.
*/
public class Toutiao {
public static void main(String[] args) throws Exception{
//等待数据加载的时间
//为了防止服务器封锁，这里的时间要模拟人的行为，随机且不能太短
long waitLoadBaseTime = 3000;
int waitLoadRandomTime = 3000;
Random random = new Random(System.currentTimeMillis());
//火狐浏览器
WebDriver driver = new FirefoxDriver();
//要抓取的网页
driver.get("http://toutiao.com/");
//等待页面动态加载完毕
Thread.sleep(waitLoadBaseTime+random.nextInt(waitLoadRandomTime));
//要加载多少页数据
int pages=5;
for(int i=0; i 查看全部
scrapy分页抓取网页(如何抓取目标网站是以Js的方式动态生成数据的网页)
我们在爬取数据的时候，如果目标网站是以Js的方式动态生成数据，以滚动页面的方式进行分页，那我们怎么爬取呢？
如今日头条网站：
我们可以使用 Selenium 来做到这一点。虽然 Selenium 是为 Web 应用程序的自动化测试而设计的，但它非常适合数据抓取，并且可以轻松绕过 网站 的反爬虫限制，因为 Selenium 直接在浏览器中运行，就像真正的用户一样.
使用Selenium，我们不仅可以爬取Js动态生成数据的网页，还可以爬取通过滚动页面进行分页的网页。
首先，我们使用maven来导入Selenium依赖：
org.seleniumhq.selenium
selenium-java
2.47.1
然后就可以编写代码进行爬取了：
<p>import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import java.util.List;
import java.util.Random;
/**
* 如何抓取Js动态生成数据且以滚动页面方式分页的网页
* 以抓取今日头条为例说明：http://toutiao.com/
* Created by ysc on 10/13/15.
*/
public class Toutiao {
public static void main(String[] args) throws Exception{
//等待数据加载的时间
//为了防止服务器封锁，这里的时间要模拟人的行为，随机且不能太短
long waitLoadBaseTime = 3000;
int waitLoadRandomTime = 3000;
Random random = new Random(System.currentTimeMillis());
//火狐浏览器
WebDriver driver = new FirefoxDriver();
//要抓取的网页
driver.get("http://toutiao.com/";);
//等待页面动态加载完毕
Thread.sleep(waitLoadBaseTime+random.nextInt(waitLoadRandomTime));
//要加载多少页数据
int pages=5;
for(int i=0; i
scrapy分页抓取网页(什么是Items呢？官方文档Items定义如下：Items)
网站优化 • 优采云 发表了文章 • 0 个评论 • 64 次浏览 • 2022-02-05 22:14
scrapy分页抓取网页(什么是Items呢？官方文档Items定义如下：Items)
什么是物品？官方文档Items定义如下：
项目
爬取的主要目标是从非结构化数据源中提取结构化数据，例如网页。Scrapy spider 可以使用 python 的 dict 返回提取的数据。dict虽然使用起来非常方便和熟悉，但缺乏结构，容易打错字段名或返回不一致的数据，尤其是在项目中有多个爬虫的大规模情况下。
为了定义通用的输出数据，Scrapy 提供了 Item 类。Item 对象是一个简单的容器，用于保存爬网数据。它提供了类似字典的 API 和用于声明可用字段的简单语法。
许多 Scrapy 组件使用 Item 提供的额外信息：exporter 根据 Item 声明的字段导出数据，序列化可以通过 Item 字段的元数据定义，trackref 跟踪 Item 实例以帮助查找内存泄漏（请参阅 Debugging with trackref 内存泄漏）等。
使用简单的类定义语法和 Field 对象来声明项目。我们打开scrapyspider目录下的items.py文件，编写如下代码声明Item：
import scrapy
class DoubanMovieItem(scrapy.Item):
# 排名
ranking = scrapy.Field()
# 电影名称
movie_name = scrapy.Field()
# 评分
score = scrapy.Field()
# 评论人数
score_num = scrapy.Field()
履带式
在scrapyspider/spiders目录下创建douban_spider.py文件，编写初步代码：
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
start_urls = ['https://movie.douban.com/top250']
def parse(self, response):
item = DoubanMovieItem()
这是一个基本的scrapy蜘蛛模型，首先我们需要在Scrapy.spiders中导入Spider类，以及我们刚刚在scrapyspider.items中定义的豆瓣电影项目。然后创建我们自己的爬虫类 DoubanMovieTop250Spider 并继承 Spider 类。scrapy.spiders中有很多不同的爬虫类供我们继承。一般来说，Spider类可以满足要求。（其他爬虫的使用请参考官方文档）。
蜘蛛
类scrapy.spider.Spider
蜘蛛是最简单的蜘蛛。每个其他蜘蛛都必须从这个类继承（包括 Scrapy 附带的其他蜘蛛和您自己编写的蜘蛛）。Spider 不提供任何特殊功能。它只是请求给定的 start_urls/start_requests 并根据返回的结果（结果响应）调用蜘蛛的 parse 方法。
name 定义蜘蛛名称的字符串。蜘蛛的名字定义了 Scrapy 如何定位（和初始化）蜘蛛，所以它必须是唯一的。但是，您可以在没有任何限制的情况下生成同一个蜘蛛的多个实例。name是spider最重要的属性，是必须的。
如果蜘蛛爬取单个 网站（单个域），通常的做法是在 网站（域）之后命名蜘蛛（带或不带后缀）。例如，如果蜘蛛正在爬行，蜘蛛通常会被命名为 mywebsite。
allowed_domains 是可选的。收录允许蜘蛛抓取的域列表。开启 OffsiteMiddleware 后，域名不在列表中的 URL 将不会被跟进。
start_urls URL 列表。当没有指定具体的 URL 时，蜘蛛会从这个列表开始爬取。因此，要获取的第一个页面的 URL 将是列表之一。后续 URL 将从获取的数据中提取。
start_requests() 这个方法必须返回一个可迭代的。该对象收录蜘蛛用来抓取的第一个请求。
当蜘蛛开始爬取并且没有指定 URL 时调用该方法。当指定 URL 时，将调用 make_requests_from_url() 来创建 Request 对象。此方法只会被 Scrapy 调用一次，因此您可以将其实现为生成器。
该方法的默认实现是使用 start_urls 的 url 来生成 Request。
如果要修改原来爬取了一个网站的Request对象，可以重写这个方法。例如，如果你需要在启动时 POST 到某个 网站，你可以这样写：
def start_requests(self):
return [scrapy.FormRequest("http://www.example.com/login",
formdata={'user': 'john', 'pass': 'secret'},
callback=self.logged_in)]
def logged_in(self, response):
# here you would extract links to follow and return Requests for
# each of them, with another callback
pass
make_requests_from_url(url) 该方法接受一个 URL 并返回一个请求对象进行爬取。该方法在初始化请求时被 start_requests() 调用，也用于将 url 转换为请求。
如果默认不覆盖，在该方法返回的Request对象中，parse()作为回调函数，dont_filter参数也设置为on。（详情请参阅请求）。
parse(response) 当response没有指定回调函数时，这个方法是Scrapy处理下载的response的默认方法。
parse 处理响应并返回处理后的数据和/或要遵循的 URL。Spider 对其他 Request 回调函数有相同的要求。
此方法和其他 Request 回调函数必须返回收录 Request 和/或 Item 的可迭代对象。
参数：响应（Response）——用于分析的响应
log(message[, level, component]) 使用 scrapy.log.msg() 方法记录（记录）消息。日志中自动携带蜘蛛的名称属性。有关更多数据，请参阅日志记录。
closed(reason) 这个函数在蜘蛛关闭时被调用。这个方法提供了一个快捷方式，而不是调用 signals.connect() 来监听 spider_close 信号。
提取网页信息
我们使用 xpath 语法来提取我们需要的信息。不熟悉xpath语法的同学可以在W3School网站中学习，很快就能上手。首先，我们在chrome浏览器中进入豆瓣电影TOP250页面，按F12打开开发者工具。
点击工具栏左上角类似鼠标的符号图标或Ctrl+Shift+c点击页面中我们想要的元素，在工具栏中查看其在网页HTML源代码中的位置。一般抓的时候，先抓大再抓小的原则。通过观察，我们可以看到该页面上所有电影的信息都位于一个类属性为grid_view的ol标签内的一个li标签中。
1
肖申克的救赎
/ The Shawshank Redemption
/ 月黑高飞(港) / 刺激1995(台)
[可播放]
导演: 弗兰克·德拉邦特 Frank Darabont 主演: 蒂姆·罗宾斯 Tim Robbins /...
1994 / 美国 / 犯罪 剧情
9.6
766719人评价
希望让人自由。
...
...
...
因此，我们按照上述原则爬取所需信息
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
start_urls = ['https://movie.douban.com/top250']
def parse(self, response):
item = DoubanMovieItem()
movies = response.xpath('//ol[@class="grid_view"]/li')
for movie in movies:
item['ranking'] = movie.xpath(
'.//div[@class="pic"]/em/text()').extract()[0]
item['movie_name'] = movie.xpath(
'.//div[@class="hd"]/a/span[1]/text()').extract()[0]
item['score'] = movie.xpath(
'.//div[@class="star"]/span[@class="rating_num"]/text()'
).extract()[0]
item['score_num'] = movie.xpath(
'.//div[@class="star"]/span/text()').re(ur'(\d+)人评价')[0]
yield item
Scrapy提取的页面信息内容详细请参考官方文档的相应章节。
运行爬虫
在项目文件夹中打开 cmd 并运行以下命令：
scrapy crawl douban_movie_top250 -o douban.csv
注意这里的douban_movie_top250是我们刚刚写的爬虫的名字，-o douban.csv是scrapy提供的一个快捷方式，可以将item输出为csv格式
尝试运行爬虫，为什么没有输出？！！！
在你所有的努力之后你会失败吗？！！！别着急，我们看下一个控制台输出的信息。原来是403错误。这是因为豆瓣给爬虫设置了一个很小的阈值，我们只需要在发送请求时更改请求头user-agent即可。
更改后的代码在某些地方感觉不同吗？为什么 start_urls 不见了？start_requests 函数有什么作用？还记得刚才对 Spider 类的介绍吗？让我们回过头来回顾一下上面对 start_urls 和 start_requests 函数的介绍。简单来说，通过使用start_requests函数，我们有了更多的权限来处理初始URL，比如这次在初始URL中加入了请求头user_agent。
再次运行爬虫，我们想要的信息全部下载到douban.scv文件夹中。直接用WPS打开查看信息。
自动翻页
不要太激动，没发现问题吗？在这种情况下，我们只能抓取到当前页面的 25 部电影的内容。我怎样才能和其他人一起爬下来？实现自动翻页一般有两种方式：
在页面中找到下一页的地址；根据 URL 的变化规律，自己构建所有的页面地址。
一般情况下我们使用第一种方式，第二种方式适用于页面的下一页地址是JS加载的情况。今天我们只讲第一种方法。先用Chrome浏览器的开发者工具找到下一页的地址
然后在解析页面的时候，得到下一页的地址，把地址交给调度器（Scheduler）
from scrapy import Request
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36',
}
def start_requests(self):
url = 'https://movie.douban.com/top250'
yield Request(url, headers=self.headers)
def parse(self, response):
item = DoubanMovieItem()
movies = response.xpath('//ol[@class="grid_view"]/li')
for movie in movies:
item['ranking'] = movie.xpath(
'.//div[@class="pic"]/em/text()').extract()[0]
item['movie_name'] = movie.xpath(
'.//div[@class="hd"]/a/span[1]/text()').extract()[0]
item['score'] = movie.xpath(
'.//div[@class="star"]/span[@class="rating_num"]/text()'
).extract()[0]
item['score_num'] = movie.xpath(
'.//div[@class="star"]/span/text()').re(ur'(\d+)人评价')[0]
yield item
next_url = response.xpath('//span[@class="next"]/a/@href').extract()
if next_url:
next_url = 'https://movie.douban.com/top250' + next_url[0]
yield Request(next_url, headers=self.headers)
最后再次运行爬虫，打开douban.csv。有没有发现已经获取了所有的电影信息，其中250个不超过1个，不小于250个？
最后，使用 WPS 的过滤功能，您可以过滤任何符合您要求的视频。（ps：外国和尚不总是会念经，记得用WPS打开这个CVS文件，用EXCEL打开会因为中文导致显示异常。）
结尾
自从写了这篇 Scrapy 爬虫框架教程后，我越来越觉得把学到的东西导出并没有想象中的那么简单。很多时候，在写了几个小时的教程之后，我发现我仍然无法完美地表达我想要表达的东西。如果有什么不对的地方，请纠正我。有一系列的听证会，并且有艺术行业的专业。我们都互相学习：）
源码地址：Wooden-Robot/scrapy-tutorial 查看全部
什么是物品？官方文档Items定义如下：
项目
爬取的主要目标是从非结构化数据源中提取结构化数据，例如网页。Scrapy spider 可以使用 python 的 dict 返回提取的数据。dict虽然使用起来非常方便和熟悉，但缺乏结构，容易打错字段名或返回不一致的数据，尤其是在项目中有多个爬虫的大规模情况下。
为了定义通用的输出数据，Scrapy 提供了 Item 类。Item 对象是一个简单的容器，用于保存爬网数据。它提供了类似字典的 API 和用于声明可用字段的简单语法。
许多 Scrapy 组件使用 Item 提供的额外信息：exporter 根据 Item 声明的字段导出数据，序列化可以通过 Item 字段的元数据定义，trackref 跟踪 Item 实例以帮助查找内存泄漏（请参阅 Debugging with trackref 内存泄漏）等。
使用简单的类定义语法和 Field 对象来声明项目。我们打开scrapyspider目录下的items.py文件，编写如下代码声明Item：
import scrapy
class DoubanMovieItem(scrapy.Item):
# 排名
ranking = scrapy.Field()
# 电影名称
movie_name = scrapy.Field()
# 评分
score = scrapy.Field()
# 评论人数
score_num = scrapy.Field()
履带式
在scrapyspider/spiders目录下创建douban_spider.py文件，编写初步代码：
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
start_urls = ['https://movie.douban.com/top250']
def parse(self, response):
item = DoubanMovieItem()
这是一个基本的scrapy蜘蛛模型，首先我们需要在Scrapy.spiders中导入Spider类，以及我们刚刚在scrapyspider.items中定义的豆瓣电影项目。然后创建我们自己的爬虫类 DoubanMovieTop250Spider 并继承 Spider 类。scrapy.spiders中有很多不同的爬虫类供我们继承。一般来说，Spider类可以满足要求。（其他爬虫的使用请参考官方文档）。
蜘蛛
类scrapy.spider.Spider
蜘蛛是最简单的蜘蛛。每个其他蜘蛛都必须从这个类继承（包括 Scrapy 附带的其他蜘蛛和您自己编写的蜘蛛）。Spider 不提供任何特殊功能。它只是请求给定的 start_urls/start_requests 并根据返回的结果（结果响应）调用蜘蛛的 parse 方法。
name 定义蜘蛛名称的字符串。蜘蛛的名字定义了 Scrapy 如何定位（和初始化）蜘蛛，所以它必须是唯一的。但是，您可以在没有任何限制的情况下生成同一个蜘蛛的多个实例。name是spider最重要的属性，是必须的。
如果蜘蛛爬取单个 网站（单个域），通常的做法是在 网站（域）之后命名蜘蛛（带或不带后缀）。例如，如果蜘蛛正在爬行，蜘蛛通常会被命名为 mywebsite。
allowed_domains 是可选的。收录允许蜘蛛抓取的域列表。开启 OffsiteMiddleware 后，域名不在列表中的 URL 将不会被跟进。
start_urls URL 列表。当没有指定具体的 URL 时，蜘蛛会从这个列表开始爬取。因此，要获取的第一个页面的 URL 将是列表之一。后续 URL 将从获取的数据中提取。
start_requests() 这个方法必须返回一个可迭代的。该对象收录蜘蛛用来抓取的第一个请求。
当蜘蛛开始爬取并且没有指定 URL 时调用该方法。当指定 URL 时，将调用 make_requests_from_url() 来创建 Request 对象。此方法只会被 Scrapy 调用一次，因此您可以将其实现为生成器。
该方法的默认实现是使用 start_urls 的 url 来生成 Request。
如果要修改原来爬取了一个网站的Request对象，可以重写这个方法。例如，如果你需要在启动时 POST 到某个 网站，你可以这样写：
def start_requests(self):
return [scrapy.FormRequest("http://www.example.com/login",
formdata={'user': 'john', 'pass': 'secret'},
callback=self.logged_in)]
def logged_in(self, response):
# here you would extract links to follow and return Requests for
# each of them, with another callback
pass
make_requests_from_url(url) 该方法接受一个 URL 并返回一个请求对象进行爬取。该方法在初始化请求时被 start_requests() 调用，也用于将 url 转换为请求。
如果默认不覆盖，在该方法返回的Request对象中，parse()作为回调函数，dont_filter参数也设置为on。（详情请参阅请求）。
parse(response) 当response没有指定回调函数时，这个方法是Scrapy处理下载的response的默认方法。
parse 处理响应并返回处理后的数据和/或要遵循的 URL。Spider 对其他 Request 回调函数有相同的要求。
此方法和其他 Request 回调函数必须返回收录 Request 和/或 Item 的可迭代对象。
参数：响应（Response）——用于分析的响应
log(message[, level, component]) 使用 scrapy.log.msg() 方法记录（记录）消息。日志中自动携带蜘蛛的名称属性。有关更多数据，请参阅日志记录。
closed(reason) 这个函数在蜘蛛关闭时被调用。这个方法提供了一个快捷方式，而不是调用 signals.connect() 来监听 spider_close 信号。
提取网页信息
我们使用 xpath 语法来提取我们需要的信息。不熟悉xpath语法的同学可以在W3School网站中学习，很快就能上手。首先，我们在chrome浏览器中进入豆瓣电影TOP250页面，按F12打开开发者工具。
点击工具栏左上角类似鼠标的符号图标或Ctrl+Shift+c点击页面中我们想要的元素，在工具栏中查看其在网页HTML源代码中的位置。一般抓的时候，先抓大再抓小的原则。通过观察，我们可以看到该页面上所有电影的信息都位于一个类属性为grid_view的ol标签内的一个li标签中。
1
肖申克的救赎
/ The Shawshank Redemption
/ 月黑高飞(港) / 刺激1995(台)
[可播放]
导演: 弗兰克·德拉邦特 Frank Darabont 主演: 蒂姆·罗宾斯 Tim Robbins /...
1994 / 美国 / 犯罪 剧情
9.6
766719人评价
希望让人自由。
...
...
...
因此，我们按照上述原则爬取所需信息
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
start_urls = ['https://movie.douban.com/top250']
def parse(self, response):
item = DoubanMovieItem()
movies = response.xpath('//ol[@class="grid_view"]/li')
for movie in movies:
item['ranking'] = movie.xpath(
'.//div[@class="pic"]/em/text()').extract()[0]
item['movie_name'] = movie.xpath(
'.//div[@class="hd"]/a/span[1]/text()').extract()[0]
item['score'] = movie.xpath(
'.//div[@class="star"]/span[@class="rating_num"]/text()'
).extract()[0]
item['score_num'] = movie.xpath(
'.//div[@class="star"]/span/text()').re(ur'(\d+)人评价')[0]
yield item
Scrapy提取的页面信息内容详细请参考官方文档的相应章节。
运行爬虫
在项目文件夹中打开 cmd 并运行以下命令：
scrapy crawl douban_movie_top250 -o douban.csv
注意这里的douban_movie_top250是我们刚刚写的爬虫的名字，-o douban.csv是scrapy提供的一个快捷方式，可以将item输出为csv格式
尝试运行爬虫，为什么没有输出？！！！
在你所有的努力之后你会失败吗？！！！别着急，我们看下一个控制台输出的信息。原来是403错误。这是因为豆瓣给爬虫设置了一个很小的阈值，我们只需要在发送请求时更改请求头user-agent即可。
更改后的代码在某些地方感觉不同吗？为什么 start_urls 不见了？start_requests 函数有什么作用？还记得刚才对 Spider 类的介绍吗？让我们回过头来回顾一下上面对 start_urls 和 start_requests 函数的介绍。简单来说，通过使用start_requests函数，我们有了更多的权限来处理初始URL，比如这次在初始URL中加入了请求头user_agent。
再次运行爬虫，我们想要的信息全部下载到douban.scv文件夹中。直接用WPS打开查看信息。
自动翻页
不要太激动，没发现问题吗？在这种情况下，我们只能抓取到当前页面的 25 部电影的内容。我怎样才能和其他人一起爬下来？实现自动翻页一般有两种方式：
在页面中找到下一页的地址；根据 URL 的变化规律，自己构建所有的页面地址。
一般情况下我们使用第一种方式，第二种方式适用于页面的下一页地址是JS加载的情况。今天我们只讲第一种方法。先用Chrome浏览器的开发者工具找到下一页的地址
然后在解析页面的时候，得到下一页的地址，把地址交给调度器（Scheduler）
from scrapy import Request
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36',
}
def start_requests(self):
url = 'https://movie.douban.com/top250'
yield Request(url, headers=self.headers)
def parse(self, response):
item = DoubanMovieItem()
movies = response.xpath('//ol[@class="grid_view"]/li')
for movie in movies:
item['ranking'] = movie.xpath(
'.//div[@class="pic"]/em/text()').extract()[0]
item['movie_name'] = movie.xpath(
'.//div[@class="hd"]/a/span[1]/text()').extract()[0]
item['score'] = movie.xpath(
'.//div[@class="star"]/span[@class="rating_num"]/text()'
).extract()[0]
item['score_num'] = movie.xpath(
'.//div[@class="star"]/span/text()').re(ur'(\d+)人评价')[0]
yield item
next_url = response.xpath('//span[@class="next"]/a/@href').extract()
if next_url:
next_url = 'https://movie.douban.com/top250' + next_url[0]
yield Request(next_url, headers=self.headers)
最后再次运行爬虫，打开douban.csv。有没有发现已经获取了所有的电影信息，其中250个不超过1个，不小于250个？
最后，使用 WPS 的过滤功能，您可以过滤任何符合您要求的视频。（ps：外国和尚不总是会念经，记得用WPS打开这个CVS文件，用EXCEL打开会因为中文导致显示异常。）
结尾
自从写了这篇 Scrapy 爬虫框架教程后，我越来越觉得把学到的东西导出并没有想象中的那么简单。很多时候，在写了几个小时的教程之后，我发现我仍然无法完美地表达我想要表达的东西。如果有什么不对的地方，请纠正我。有一系列的听证会，并且有艺术行业的专业。我们都互相学习：）
源码地址：Wooden-Robot/scrapy-tutorial 查看全部
scrapy分页抓取网页(什么是Items呢？官方文档Items定义如下：Items)
什么是物品？官方文档Items定义如下：
项目
爬取的主要目标是从非结构化数据源中提取结构化数据，例如网页。Scrapy spider 可以使用 python 的 dict 返回提取的数据。dict虽然使用起来非常方便和熟悉，但缺乏结构，容易打错字段名或返回不一致的数据，尤其是在项目中有多个爬虫的大规模情况下。
为了定义通用的输出数据，Scrapy 提供了 Item 类。Item 对象是一个简单的容器，用于保存爬网数据。它提供了类似字典的 API 和用于声明可用字段的简单语法。
许多 Scrapy 组件使用 Item 提供的额外信息：exporter 根据 Item 声明的字段导出数据，序列化可以通过 Item 字段的元数据定义，trackref 跟踪 Item 实例以帮助查找内存泄漏（请参阅 Debugging with trackref 内存泄漏）等。
使用简单的类定义语法和 Field 对象来声明项目。我们打开scrapyspider目录下的items.py文件，编写如下代码声明Item：
import scrapy
class DoubanMovieItem(scrapy.Item):
# 排名
ranking = scrapy.Field()
# 电影名称
movie_name = scrapy.Field()
# 评分
score = scrapy.Field()
# 评论人数
score_num = scrapy.Field()
履带式
在scrapyspider/spiders目录下创建douban_spider.py文件，编写初步代码：
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
start_urls = ['https://movie.douban.com/top250']
def parse(self, response):
item = DoubanMovieItem()
这是一个基本的scrapy蜘蛛模型，首先我们需要在Scrapy.spiders中导入Spider类，以及我们刚刚在scrapyspider.items中定义的豆瓣电影项目。然后创建我们自己的爬虫类 DoubanMovieTop250Spider 并继承 Spider 类。scrapy.spiders中有很多不同的爬虫类供我们继承。一般来说，Spider类可以满足要求。（其他爬虫的使用请参考官方文档）。
蜘蛛
类scrapy.spider.Spider
蜘蛛是最简单的蜘蛛。每个其他蜘蛛都必须从这个类继承（包括 Scrapy 附带的其他蜘蛛和您自己编写的蜘蛛）。Spider 不提供任何特殊功能。它只是请求给定的 start_urls/start_requests 并根据返回的结果（结果响应）调用蜘蛛的 parse 方法。
name 定义蜘蛛名称的字符串。蜘蛛的名字定义了 Scrapy 如何定位（和初始化）蜘蛛，所以它必须是唯一的。但是，您可以在没有任何限制的情况下生成同一个蜘蛛的多个实例。name是spider最重要的属性，是必须的。
如果蜘蛛爬取单个 网站（单个域），通常的做法是在 网站（域）之后命名蜘蛛（带或不带后缀）。例如，如果蜘蛛正在爬行，蜘蛛通常会被命名为 mywebsite。
allowed_domains 是可选的。收录允许蜘蛛抓取的域列表。开启 OffsiteMiddleware 后，域名不在列表中的 URL 将不会被跟进。
start_urls URL 列表。当没有指定具体的 URL 时，蜘蛛会从这个列表开始爬取。因此，要获取的第一个页面的 URL 将是列表之一。后续 URL 将从获取的数据中提取。
start_requests() 这个方法必须返回一个可迭代的。该对象收录蜘蛛用来抓取的第一个请求。
当蜘蛛开始爬取并且没有指定 URL 时调用该方法。当指定 URL 时，将调用 make_requests_from_url() 来创建 Request 对象。此方法只会被 Scrapy 调用一次，因此您可以将其实现为生成器。
该方法的默认实现是使用 start_urls 的 url 来生成 Request。
如果要修改原来爬取了一个网站的Request对象，可以重写这个方法。例如，如果你需要在启动时 POST 到某个 网站，你可以这样写：
def start_requests(self):
return [scrapy.FormRequest("http://www.example.com/login",
formdata={'user': 'john', 'pass': 'secret'},
callback=self.logged_in)]
def logged_in(self, response):
# here you would extract links to follow and return Requests for
# each of them, with another callback
pass
make_requests_from_url(url) 该方法接受一个 URL 并返回一个请求对象进行爬取。该方法在初始化请求时被 start_requests() 调用，也用于将 url 转换为请求。
如果默认不覆盖，在该方法返回的Request对象中，parse()作为回调函数，dont_filter参数也设置为on。（详情请参阅请求）。
parse(response) 当response没有指定回调函数时，这个方法是Scrapy处理下载的response的默认方法。
parse 处理响应并返回处理后的数据和/或要遵循的 URL。Spider 对其他 Request 回调函数有相同的要求。
此方法和其他 Request 回调函数必须返回收录 Request 和/或 Item 的可迭代对象。
参数：响应（Response）——用于分析的响应
log(message[, level, component]) 使用 scrapy.log.msg() 方法记录（记录）消息。日志中自动携带蜘蛛的名称属性。有关更多数据，请参阅日志记录。
closed(reason) 这个函数在蜘蛛关闭时被调用。这个方法提供了一个快捷方式，而不是调用 signals.connect() 来监听 spider_close 信号。
提取网页信息
我们使用 xpath 语法来提取我们需要的信息。不熟悉xpath语法的同学可以在W3School网站中学习，很快就能上手。首先，我们在chrome浏览器中进入豆瓣电影TOP250页面，按F12打开开发者工具。
点击工具栏左上角类似鼠标的符号图标或Ctrl+Shift+c点击页面中我们想要的元素，在工具栏中查看其在网页HTML源代码中的位置。一般抓的时候，先抓大再抓小的原则。通过观察，我们可以看到该页面上所有电影的信息都位于一个类属性为grid_view的ol标签内的一个li标签中。
1
肖申克的救赎
/ The Shawshank Redemption
/ 月黑高飞(港) / 刺激1995(台)
[可播放]
导演: 弗兰克·德拉邦特 Frank Darabont 主演: 蒂姆·罗宾斯 Tim Robbins /...
1994 / 美国 / 犯罪 剧情
9.6
766719人评价
希望让人自由。
...
...
...
因此，我们按照上述原则爬取所需信息
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
start_urls = ['https://movie.douban.com/top250']
def parse(self, response):
item = DoubanMovieItem()
movies = response.xpath('//ol[@class="grid_view"]/li')
for movie in movies:
item['ranking'] = movie.xpath(
'.//div[@class="pic"]/em/text()').extract()[0]
item['movie_name'] = movie.xpath(
'.//div[@class="hd"]/a/span[1]/text()').extract()[0]
item['score'] = movie.xpath(
'.//div[@class="star"]/span[@class="rating_num"]/text()'
).extract()[0]
item['score_num'] = movie.xpath(
'.//div[@class="star"]/span/text()').re(ur'(\d+)人评价')[0]
yield item
Scrapy提取的页面信息内容详细请参考官方文档的相应章节。
运行爬虫
在项目文件夹中打开 cmd 并运行以下命令：
scrapy crawl douban_movie_top250 -o douban.csv
注意这里的douban_movie_top250是我们刚刚写的爬虫的名字，-o douban.csv是scrapy提供的一个快捷方式，可以将item输出为csv格式
尝试运行爬虫，为什么没有输出？！！！
在你所有的努力之后你会失败吗？！！！别着急，我们看下一个控制台输出的信息。原来是403错误。这是因为豆瓣给爬虫设置了一个很小的阈值，我们只需要在发送请求时更改请求头user-agent即可。
更改后的代码在某些地方感觉不同吗？为什么 start_urls 不见了？start_requests 函数有什么作用？还记得刚才对 Spider 类的介绍吗？让我们回过头来回顾一下上面对 start_urls 和 start_requests 函数的介绍。简单来说，通过使用start_requests函数，我们有了更多的权限来处理初始URL，比如这次在初始URL中加入了请求头user_agent。
再次运行爬虫，我们想要的信息全部下载到douban.scv文件夹中。直接用WPS打开查看信息。
自动翻页
不要太激动，没发现问题吗？在这种情况下，我们只能抓取到当前页面的 25 部电影的内容。我怎样才能和其他人一起爬下来？实现自动翻页一般有两种方式：
在页面中找到下一页的地址；根据 URL 的变化规律，自己构建所有的页面地址。
一般情况下我们使用第一种方式，第二种方式适用于页面的下一页地址是JS加载的情况。今天我们只讲第一种方法。先用Chrome浏览器的开发者工具找到下一页的地址
然后在解析页面的时候，得到下一页的地址，把地址交给调度器（Scheduler）
from scrapy import Request
from scrapy.spiders import Spider
from scrapyspider.items import DoubanMovieItem
class DoubanMovieTop250Spider(Spider):
name = 'douban_movie_top250'
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36',
}
def start_requests(self):
url = 'https://movie.douban.com/top250'
yield Request(url, headers=self.headers)
def parse(self, response):
item = DoubanMovieItem()
movies = response.xpath('//ol[@class="grid_view"]/li')
for movie in movies:
item['ranking'] = movie.xpath(
'.//div[@class="pic"]/em/text()').extract()[0]
item['movie_name'] = movie.xpath(
'.//div[@class="hd"]/a/span[1]/text()').extract()[0]
item['score'] = movie.xpath(
'.//div[@class="star"]/span[@class="rating_num"]/text()'
).extract()[0]
item['score_num'] = movie.xpath(
'.//div[@class="star"]/span/text()').re(ur'(\d+)人评价')[0]
yield item
next_url = response.xpath('//span[@class="next"]/a/@href').extract()
if next_url:
next_url = 'https://movie.douban.com/top250' + next_url[0]
yield Request(next_url, headers=self.headers)
最后再次运行爬虫，打开douban.csv。有没有发现已经获取了所有的电影信息，其中250个不超过1个，不小于250个？
最后，使用 WPS 的过滤功能，您可以过滤任何符合您要求的视频。（ps：外国和尚不总是会念经，记得用WPS打开这个CVS文件，用EXCEL打开会因为中文导致显示异常。）
结尾
自从写了这篇 Scrapy 爬虫框架教程后，我越来越觉得把学到的东西导出并没有想象中的那么简单。很多时候，在写了几个小时的教程之后，我发现我仍然无法完美地表达我想要表达的东西。如果有什么不对的地方，请纠正我。有一系列的听证会，并且有艺术行业的专业。我们都互相学习：）
源码地址：Wooden-Robot/scrapy-tutorial
scrapy分页抓取网页( Scrapy二.准备环境三.使用框架1.创建项目使用命令)
网站优化 • 优采云 发表了文章 • 0 个评论 • 46 次浏览 • 2022-02-05 07:22
scrapy分页抓取网页(
Scrapy二.准备环境三.使用框架1.创建项目使用命令)
Python爬虫学习的scrapy框架（一）爬取豆瓣书单
文章目录
Python爬虫学习的scrapy框架（一）爬取豆瓣书单
资源链接
一.什么是 Scrapy
二.准备环境
三.一般流程
四.使用框架
1.创建项目
2.各部分介绍
3.创建爬虫
4.设置数据存储模板
5.分析网页，编写爬虫
6.数据处理
7.设置部分
8.执行爬虫
一.什么是 Scrapy
Scrapy 是一个应用程序框架，用于抓取 网站 数据并提取结构化数据。它可以用于一系列程序，包括数据挖掘、信息处理或存储历史数据。自己写一个Python爬虫也不是不行，但是有框架可以用，何乐而不为呢？相信Scrapy可以事半功倍。与 request 相比，scrapy 侧重于爬虫框架，而不是页面下载。
二.准备环境
scrapy爬虫pypiwin32、lxml、twisted、scrapy、Microsoft Visual C++ 14.0或以上编译环境所需的库
数据库连接模块，pymysql，我用pip安装了上面的库，这里放了清华大学的镜像源 -i /simple
三.一般流程
首先，引擎从调度程序中获取一个链接（URL）用于后续爬取
1.引擎将URL封装成请求（Request）传给下载器，下载器下载资源并封装成响应包（Response）
2.然后，爬虫解析Response。
3.如果实体（Item）被解析，就会交给实体管道做进一步处理。
4.如果解析了一个链接（URL），则将该URL交给Scheduler进行爬取。
四.使用框架创建项目1.
使用命令scrapy startproject projectname
PS D:\pythonpractice> scrapy startproject douban
New Scrapy project 'douban', using template directory 'D:\python38install\Lib\site-packages\scrapy\templates\project', created in:
D:\pythonpractice\douban
You can start your first spider with:
cd douban
scrapy genspider example example.com
我在用vscode，用ctrl和·键唤起终端，输入命令，我要去爬豆瓣的一些页面，所以我把它命名为豆瓣，可以看到你打开的文件夹下出现了一个新文件夹，这是我命名的那个
然后使用cd douban命令进入项目所在文件夹
PS D:\pythonpractice> cd douban
PS D:\pythonpractice\douban>
2.各部分介绍
在项目文件夹中，可以看到还有一个与项目同名的文件夹，里面收录了一些文件，
1.items.py 负责建立数据模型，为结构化数据设置数据存储模板，如：Django的Model
2.middlewares.py 是你自己定义的中间件
3.pipelines.py 负责处理spider返回的数据，比如数据持久化
4.settings.py 负责整个爬虫的配置
5.spiders目录负责存放从scrapy继承而来的爬虫类
6.scrapy.cfg 是scrapy的基本配置
3.创建爬虫
使用 scrapy genspider [options] 创建自己的爬虫，
我进入scrapy genspider book，即创建一个叫book的爬虫，domain部分就是爬虫的范围，爬取的网页不能超过这个域名。
4.设置数据存储模板
修改item.py如下
import scrapy
class DoubanItem(scrapy.Item):
# define the fields for your item here like:
# name = scrapy.Field()
title = scrapy.Field()
img_src = scrapy.Field()
score = scrapy.Field()
publish_house = scrapy.Field()
publish_detail = scrapy.Field()
slogan = scrapy.Field()
detail_addr = scrapy.Field()
comment_people = scrapy.Field()
5.分析网页，编写爬虫
打开网址链接：豆瓣阅读Top 250(/top250)
F12 打开网页的源代码，
可以看出结构很清晰，我需要的是这本书的资料，写book.py如下，
class BookSpider(scrapy.Spider):
name = 'book'
allowed_domains = ['douban.com']
start_urls = ['https://book.douban.com/top250?start=0']
url_sets = set()
def parse(self, response):
if response.url.startswith('https://book.douban.com'):
seclectors = response.xpath('//div[@class="indent"]/table')
for seclector in seclectors:
item = DoubanItem()
item['title'] = seclector.xpath("./tr/td[2]/div/a/@title").extract()[0]
item['img_src'] = seclector.xpath("./tr/td[1]/a/img/@src").extract()[0]
item['publish_detail'] = seclector.xpath("./tr/td[2]/p[@class='pl']/text()").extract()[0]
item['score'] = seclector.xpath("./tr/td[2]/div[@class='star clearfix']/span[@class='rating_nums']/text()").extract()[0]
item['detail_addr'] = seclector.xpath("./tr/td[2]/div[@class='pl2']/a/@href").extract()[0]
#标语爬取
item['slogan'] = seclector.xpath("./tr/td[2]/p[@class='quote']/span/text()").get()
if item['slogan']:
pass
else:
item['slogan'] = '暂无信息'
#评论人数爬取
item['comment_people'] = seclector.xpath("./tr/td[2]/div[@class='star clearfix']/span[@class='pl']/text()").extract()[0]
comment = str(item['comment_people'])
rex = '[0-9]+'
num = re.findall(rex, comment)
if num:
item['comment_people'] = num[0]
else:
item['comment_people'] = '暂无信息'
#出版社爬取
t = str(item['publish_detail'])
s = t.encode() #进行字符串转义
temp = s.decode('utf-8')
pattern="[\u4e00-\u9fa5]*\u51fa\u7248[\u4e00-\u9fa5]*|[\u4e00-\u9fa5]*\u4E66\u5E97[\u4e00-\u9fa5]*" #中文 unicode编码出版 正则表达式
results = re.findall(pattern, temp) #匹配
if results:
item['publish_house'] = results[0]
else:
item['publish_house'] = '暂无信息'
yield item
#分页处理
urls = response.xpath("//div[@class='paginator']/span[@class='next']/a/@href").extract()
for url in urls:
if url.startswith('https://book.douban.com'):
if url in self.url_sets:
pass
else:
self.url_sets.add(url)
yield self.make_requests_from_url(url)
else:
pass
（1）这里start_urls是起始页，后面的页面都是从网页的pager中获取的，但是如果网站使用js进行分页，那就没办法了。
(2）提取网页内容的方法有很多，比如beautifulsoup、lxml，但是scrapy中默认的是selector，相对来说最好用xpath来分析页面，xpath可以自己找了解只是为爬虫分析网页并不是很困难。
（3）对于一本书的封面图，得到它的地址后，可以选择保存到本地，但是由于我个人PC端mysql不喜欢放图片，所以总觉得不是很靠谱，刚爬下它的地址，如果你写了网站，想用这些图片，应该可以直接用地址。
(4）出版商信息爬取部分，由于这个是由作者/出版商/日期/价格组成的，所以我用了一个收录“出版商”、“书店”等关键字的正则表达式字符串。提取出来方便数据持久化后的数据分析。
6.数据处理
编写 pipline.py 如下
from itemadapter import ItemAdapter
import urllib.request
import os
import pymysql
class DoubanPipeline:
def process_item(self, item, spider):
#保存图片
# url = item['img_addr']
# req = urllib.request.Request(url)
# with urllib.request.urlopen(req) as pic:
# data = pic.read()
# file_name = os.path.join(r'D:\bookpic',item['name'] + '.jpg')
# with open(file_name, 'wb') as fp:
# fp.write(data)
#保存到数据库
info = [item['title'], item['score'], item['publish_detail'], item['slogan'], item['publish_house'], item['img_src'], item['detail_addr'], item['comment_people']]
connection = pymysql.connect(host='localhost', user='root', password='', database='', charset='utf8')
try:
with connection.cursor() as cursor:
sql = 'insert into app_book (title, score, publish_detail, slogan, publish_house, img_src, detail_addr, comment_people) values (%s, %s, %s, %s, %s, %s, %s, %s)'
affectedcount = cursor.execute(sql, info)
print('成功修改{0}条数据'.format(affectedcount))
connection.commit()
except pymysql.DatabaseError:
connection.rollback()
finally:
connection.close()
return item
7.设置部分
settings.py 添加如下内容
(1）设置处理返回数据的类和执行优先级
ITEM_PIPELINES = {
'douban.pipelines.DoubanPipeline': 100,
}
(2）添加用户代理
DEFAULT_REQUEST_HEADERS = {
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language': 'en',
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:52.0) G ecko/20100101 Firefox/52.0'
}
8.执行爬虫
输入命令scrapy crawl book，爬虫开始执行 查看全部
Scrapy二.准备环境三.使用框架1.创建项目使用命令)
Python爬虫学习的scrapy框架（一）爬取豆瓣书单
文章目录
Python爬虫学习的scrapy框架（一）爬取豆瓣书单
资源链接
一.什么是 Scrapy
二.准备环境
三.一般流程
四.使用框架
1.创建项目
2.各部分介绍
3.创建爬虫
4.设置数据存储模板
5.分析网页，编写爬虫
6.数据处理
7.设置部分
8.执行爬虫
一.什么是 Scrapy
Scrapy 是一个应用程序框架，用于抓取 网站 数据并提取结构化数据。它可以用于一系列程序，包括数据挖掘、信息处理或存储历史数据。自己写一个Python爬虫也不是不行，但是有框架可以用，何乐而不为呢？相信Scrapy可以事半功倍。与 request 相比，scrapy 侧重于爬虫框架，而不是页面下载。
二.准备环境
scrapy爬虫pypiwin32、lxml、twisted、scrapy、Microsoft Visual C++ 14.0或以上编译环境所需的库
数据库连接模块，pymysql，我用pip安装了上面的库，这里放了清华大学的镜像源 -i /simple
三.一般流程
首先，引擎从调度程序中获取一个链接（URL）用于后续爬取
1.引擎将URL封装成请求（Request）传给下载器，下载器下载资源并封装成响应包（Response）
2.然后，爬虫解析Response。
3.如果实体（Item）被解析，就会交给实体管道做进一步处理。
4.如果解析了一个链接（URL），则将该URL交给Scheduler进行爬取。
四.使用框架创建项目1.
使用命令scrapy startproject projectname
PS D:\pythonpractice> scrapy startproject douban
New Scrapy project 'douban', using template directory 'D:\python38install\Lib\site-packages\scrapy\templates\project', created in:
D:\pythonpractice\douban
You can start your first spider with:
cd douban
scrapy genspider example example.com
我在用vscode，用ctrl和·键唤起终端，输入命令，我要去爬豆瓣的一些页面，所以我把它命名为豆瓣，可以看到你打开的文件夹下出现了一个新文件夹，这是我命名的那个
然后使用cd douban命令进入项目所在文件夹
PS D:\pythonpractice> cd douban
PS D:\pythonpractice\douban>
2.各部分介绍
在项目文件夹中，可以看到还有一个与项目同名的文件夹，里面收录了一些文件，
1.items.py 负责建立数据模型，为结构化数据设置数据存储模板，如：Django的Model
2.middlewares.py 是你自己定义的中间件
3.pipelines.py 负责处理spider返回的数据，比如数据持久化
4.settings.py 负责整个爬虫的配置
5.spiders目录负责存放从scrapy继承而来的爬虫类
6.scrapy.cfg 是scrapy的基本配置
3.创建爬虫
使用 scrapy genspider [options] 创建自己的爬虫，
我进入scrapy genspider book，即创建一个叫book的爬虫，domain部分就是爬虫的范围，爬取的网页不能超过这个域名。
4.设置数据存储模板
修改item.py如下
import scrapy
class DoubanItem(scrapy.Item):
# define the fields for your item here like:
# name = scrapy.Field()
title = scrapy.Field()
img_src = scrapy.Field()
score = scrapy.Field()
publish_house = scrapy.Field()
publish_detail = scrapy.Field()
slogan = scrapy.Field()
detail_addr = scrapy.Field()
comment_people = scrapy.Field()
5.分析网页，编写爬虫
打开网址链接：豆瓣阅读Top 250(/top250)
F12 打开网页的源代码，
可以看出结构很清晰，我需要的是这本书的资料，写book.py如下，
class BookSpider(scrapy.Spider):
name = 'book'
allowed_domains = ['douban.com']
start_urls = ['https://book.douban.com/top250?start=0']
url_sets = set()
def parse(self, response):
if response.url.startswith('https://book.douban.com'):
seclectors = response.xpath('//div[@class="indent"]/table')
for seclector in seclectors:
item = DoubanItem()
item['title'] = seclector.xpath("./tr/td[2]/div/a/@title").extract()[0]
item['img_src'] = seclector.xpath("./tr/td[1]/a/img/@src").extract()[0]
item['publish_detail'] = seclector.xpath("./tr/td[2]/p[@class='pl']/text()").extract()[0]
item['score'] = seclector.xpath("./tr/td[2]/div[@class='star clearfix']/span[@class='rating_nums']/text()").extract()[0]
item['detail_addr'] = seclector.xpath("./tr/td[2]/div[@class='pl2']/a/@href").extract()[0]
#标语爬取
item['slogan'] = seclector.xpath("./tr/td[2]/p[@class='quote']/span/text()").get()
if item['slogan']:
pass
else:
item['slogan'] = '暂无信息'
#评论人数爬取
item['comment_people'] = seclector.xpath("./tr/td[2]/div[@class='star clearfix']/span[@class='pl']/text()").extract()[0]
comment = str(item['comment_people'])
rex = '[0-9]+'
num = re.findall(rex, comment)
if num:
item['comment_people'] = num[0]
else:
item['comment_people'] = '暂无信息'
#出版社爬取
t = str(item['publish_detail'])
s = t.encode() #进行字符串转义
temp = s.decode('utf-8')
pattern="[\u4e00-\u9fa5]*\u51fa\u7248[\u4e00-\u9fa5]*|[\u4e00-\u9fa5]*\u4E66\u5E97[\u4e00-\u9fa5]*" #中文 unicode编码出版 正则表达式
results = re.findall(pattern, temp) #匹配
if results:
item['publish_house'] = results[0]
else:
item['publish_house'] = '暂无信息'
yield item
#分页处理
urls = response.xpath("//div[@class='paginator']/span[@class='next']/a/@href").extract()
for url in urls:
if url.startswith('https://book.douban.com'):
if url in self.url_sets:
pass
else:
self.url_sets.add(url)
yield self.make_requests_from_url(url)
else:
pass
（1）这里start_urls是起始页，后面的页面都是从网页的pager中获取的，但是如果网站使用js进行分页，那就没办法了。
(2）提取网页内容的方法有很多，比如beautifulsoup、lxml，但是scrapy中默认的是selector，相对来说最好用xpath来分析页面，xpath可以自己找了解只是为爬虫分析网页并不是很困难。
（3）对于一本书的封面图，得到它的地址后，可以选择保存到本地，但是由于我个人PC端mysql不喜欢放图片，所以总觉得不是很靠谱，刚爬下它的地址，如果你写了网站，想用这些图片，应该可以直接用地址。
(4）出版商信息爬取部分，由于这个是由作者/出版商/日期/价格组成的，所以我用了一个收录“出版商”、“书店”等关键字的正则表达式字符串。提取出来方便数据持久化后的数据分析。
6.数据处理
编写 pipline.py 如下
from itemadapter import ItemAdapter
import urllib.request
import os
import pymysql
class DoubanPipeline:
def process_item(self, item, spider):
#保存图片
# url = item['img_addr']
# req = urllib.request.Request(url)
# with urllib.request.urlopen(req) as pic:
# data = pic.read()
# file_name = os.path.join(r'D:\bookpic',item['name'] + '.jpg')
# with open(file_name, 'wb') as fp:
# fp.write(data)
#保存到数据库
info = [item['title'], item['score'], item['publish_detail'], item['slogan'], item['publish_house'], item['img_src'], item['detail_addr'], item['comment_people']]
connection = pymysql.connect(host='localhost', user='root', password='', database='', charset='utf8')
try:
with connection.cursor() as cursor:
sql = 'insert into app_book (title, score, publish_detail, slogan, publish_house, img_src, detail_addr, comment_people) values (%s, %s, %s, %s, %s, %s, %s, %s)'
affectedcount = cursor.execute(sql, info)
print('成功修改{0}条数据'.format(affectedcount))
connection.commit()
except pymysql.DatabaseError:
connection.rollback()
finally:
connection.close()
return item
7.设置部分
settings.py 添加如下内容
(1）设置处理返回数据的类和执行优先级
ITEM_PIPELINES = {
'douban.pipelines.DoubanPipeline': 100,
}
(2）添加用户代理
DEFAULT_REQUEST_HEADERS = {
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language': 'en',
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:52.0) G ecko/20100101 Firefox/52.0'
}
8.执行爬虫
输入命令scrapy crawl book，爬虫开始执行 查看全部
scrapy分页抓取网页(
Scrapy二.准备环境三.使用框架1.创建项目使用命令)
Python爬虫学习的scrapy框架（一）爬取豆瓣书单
文章目录
Python爬虫学习的scrapy框架（一）爬取豆瓣书单
资源链接
一.什么是 Scrapy
二.准备环境
三.一般流程
四.使用框架
1.创建项目
2.各部分介绍
3.创建爬虫
4.设置数据存储模板
5.分析网页，编写爬虫
6.数据处理
7.设置部分
8.执行爬虫
一.什么是 Scrapy
Scrapy 是一个应用程序框架，用于抓取 网站 数据并提取结构化数据。它可以用于一系列程序，包括数据挖掘、信息处理或存储历史数据。自己写一个Python爬虫也不是不行，但是有框架可以用，何乐而不为呢？相信Scrapy可以事半功倍。与 request 相比，scrapy 侧重于爬虫框架，而不是页面下载。
二.准备环境
scrapy爬虫pypiwin32、lxml、twisted、scrapy、Microsoft Visual C++ 14.0或以上编译环境所需的库
数据库连接模块，pymysql，我用pip安装了上面的库，这里放了清华大学的镜像源 -i /simple
三.一般流程
首先，引擎从调度程序中获取一个链接（URL）用于后续爬取
1.引擎将URL封装成请求（Request）传给下载器，下载器下载资源并封装成响应包（Response）
2.然后，爬虫解析Response。
3.如果实体（Item）被解析，就会交给实体管道做进一步处理。
4.如果解析了一个链接（URL），则将该URL交给Scheduler进行爬取。
四.使用框架创建项目1.
使用命令scrapy startproject projectname
PS D:\pythonpractice> scrapy startproject douban
New Scrapy project 'douban', using template directory 'D:\python38install\Lib\site-packages\scrapy\templates\project', created in:
D:\pythonpractice\douban
You can start your first spider with:
cd douban
scrapy genspider example example.com
我在用vscode，用ctrl和·键唤起终端，输入命令，我要去爬豆瓣的一些页面，所以我把它命名为豆瓣，可以看到你打开的文件夹下出现了一个新文件夹，这是我命名的那个
然后使用cd douban命令进入项目所在文件夹
PS D:\pythonpractice> cd douban
PS D:\pythonpractice\douban>
2.各部分介绍
在项目文件夹中，可以看到还有一个与项目同名的文件夹，里面收录了一些文件，
1.items.py 负责建立数据模型，为结构化数据设置数据存储模板，如：Django的Model
2.middlewares.py 是你自己定义的中间件
3.pipelines.py 负责处理spider返回的数据，比如数据持久化
4.settings.py 负责整个爬虫的配置
5.spiders目录负责存放从scrapy继承而来的爬虫类
6.scrapy.cfg 是scrapy的基本配置
3.创建爬虫
使用 scrapy genspider [options] 创建自己的爬虫，
我进入scrapy genspider book，即创建一个叫book的爬虫，domain部分就是爬虫的范围，爬取的网页不能超过这个域名。
4.设置数据存储模板
修改item.py如下
import scrapy
class DoubanItem(scrapy.Item):
# define the fields for your item here like:
# name = scrapy.Field()
title = scrapy.Field()
img_src = scrapy.Field()
score = scrapy.Field()
publish_house = scrapy.Field()
publish_detail = scrapy.Field()
slogan = scrapy.Field()
detail_addr = scrapy.Field()
comment_people = scrapy.Field()
5.分析网页，编写爬虫
打开网址链接：豆瓣阅读Top 250(/top250)
F12 打开网页的源代码，
可以看出结构很清晰，我需要的是这本书的资料，写book.py如下，
class BookSpider(scrapy.Spider):
name = 'book'
allowed_domains = ['douban.com']
start_urls = ['https://book.douban.com/top250?start=0']
url_sets = set()
def parse(self, response):
if response.url.startswith('https://book.douban.com'):
seclectors = response.xpath('//div[@class="indent"]/table')
for seclector in seclectors:
item = DoubanItem()
item['title'] = seclector.xpath("./tr/td[2]/div/a/@title").extract()[0]
item['img_src'] = seclector.xpath("./tr/td[1]/a/img/@src").extract()[0]
item['publish_detail'] = seclector.xpath("./tr/td[2]/p[@class='pl']/text()").extract()[0]
item['score'] = seclector.xpath("./tr/td[2]/div[@class='star clearfix']/span[@class='rating_nums']/text()").extract()[0]
item['detail_addr'] = seclector.xpath("./tr/td[2]/div[@class='pl2']/a/@href").extract()[0]
#标语爬取
item['slogan'] = seclector.xpath("./tr/td[2]/p[@class='quote']/span/text()").get()
if item['slogan']:
pass
else:
item['slogan'] = '暂无信息'
#评论人数爬取
item['comment_people'] = seclector.xpath("./tr/td[2]/div[@class='star clearfix']/span[@class='pl']/text()").extract()[0]
comment = str(item['comment_people'])
rex = '[0-9]+'
num = re.findall(rex, comment)
if num:
item['comment_people'] = num[0]
else:
item['comment_people'] = '暂无信息'
#出版社爬取
t = str(item['publish_detail'])
s = t.encode() #进行字符串转义
temp = s.decode('utf-8')
pattern="[\u4e00-\u9fa5]*\u51fa\u7248[\u4e00-\u9fa5]*|[\u4e00-\u9fa5]*\u4E66\u5E97[\u4e00-\u9fa5]*" #中文 unicode编码出版 正则表达式
results = re.findall(pattern, temp) #匹配
if results:
item['publish_house'] = results[0]
else:
item['publish_house'] = '暂无信息'
yield item
#分页处理
urls = response.xpath("//div[@class='paginator']/span[@class='next']/a/@href").extract()
for url in urls:
if url.startswith('https://book.douban.com'):
if url in self.url_sets:
pass
else:
self.url_sets.add(url)
yield self.make_requests_from_url(url)
else:
pass
（1）这里start_urls是起始页，后面的页面都是从网页的pager中获取的，但是如果网站使用js进行分页，那就没办法了。
(2）提取网页内容的方法有很多，比如beautifulsoup、lxml，但是scrapy中默认的是selector，相对来说最好用xpath来分析页面，xpath可以自己找了解只是为爬虫分析网页并不是很困难。
（3）对于一本书的封面图，得到它的地址后，可以选择保存到本地，但是由于我个人PC端mysql不喜欢放图片，所以总觉得不是很靠谱，刚爬下它的地址，如果你写了网站，想用这些图片，应该可以直接用地址。
(4）出版商信息爬取部分，由于这个是由作者/出版商/日期/价格组成的，所以我用了一个收录“出版商”、“书店”等关键字的正则表达式字符串。提取出来方便数据持久化后的数据分析。
6.数据处理
编写 pipline.py 如下
from itemadapter import ItemAdapter
import urllib.request
import os
import pymysql
class DoubanPipeline:
def process_item(self, item, spider):
#保存图片
# url = item['img_addr']
# req = urllib.request.Request(url)
# with urllib.request.urlopen(req) as pic:
# data = pic.read()
# file_name = os.path.join(r'D:\bookpic',item['name'] + '.jpg')
# with open(file_name, 'wb') as fp:
# fp.write(data)
#保存到数据库
info = [item['title'], item['score'], item['publish_detail'], item['slogan'], item['publish_house'], item['img_src'], item['detail_addr'], item['comment_people']]
connection = pymysql.connect(host='localhost', user='root', password='', database='', charset='utf8')
try:
with connection.cursor() as cursor:
sql = 'insert into app_book (title, score, publish_detail, slogan, publish_house, img_src, detail_addr, comment_people) values (%s, %s, %s, %s, %s, %s, %s, %s)'
affectedcount = cursor.execute(sql, info)
print('成功修改{0}条数据'.format(affectedcount))
connection.commit()
except pymysql.DatabaseError:
connection.rollback()
finally:
connection.close()
return item
7.设置部分
settings.py 添加如下内容
(1）设置处理返回数据的类和执行优先级
ITEM_PIPELINES = {
'douban.pipelines.DoubanPipeline': 100,
}
(2）添加用户代理
DEFAULT_REQUEST_HEADERS = {
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language': 'en',
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:52.0) G ecko/20100101 Firefox/52.0'
}
8.执行爬虫
输入命令scrapy crawl book，爬虫开始执行
scrapy分页抓取网页(Python开发的一个web抓取框架（上）|官网)
网站优化 • 优采云 发表了文章 • 0 个评论 • 60 次浏览 • 2022-02-05 07:21
scrapy分页抓取网页(Python开发的一个web抓取框架（上）|官网)
Scrapy，一个用 Python 开发的网页抓取框架。
1 简介
Python 即时网络爬虫最初的目标是把互联网变成一个大数据库。纯开源代码并不是开源的全部。开源的核心是“开放思维”，它聚合了最好的想法、技术和人才。所以会提到很多主导产品，比如Scrapy、ScrapingHub、Import.io等。
本文简要介绍了 Scrapy 的架构。是的，通用提取器 gsExtractor 将被集成到 Scrapy 架构中。
请注意，本文不想重复原文内容，而是为开源Python爬虫的发展方向寻找参考，并以近9年开发网络爬虫的经验为基准，所以这篇文章收录了作者的很多主观评论。如果想阅读Scrapy官方原文，请点击Scrapy官网架构。
2、Scrapy架构图
蜘蛛是为特定目标编写的内容提取器网站，这是通用网络爬虫框架中最可定制的部分。当你使用 Scrapy 创建爬虫项目时，会生成一个爬虫架。只需填写代码，根据其运行方式填写，即可融入到Scrapy的整体数据流中。Python实时网络爬虫开源项目的目标是节省程序员一半以上的时间。关键是提高Spider的定义和测试速度。解决方案见1分钟快速生成网页内容提取器，让整个Scrapy爬虫系统达到快速定制的目的。
3、Scrapy的数据流（Data Flow）
Scrapy 中的数据流由执行引擎控制。以下原文摘自 Scrapy 官网。我根据自己的猜测发表评论，为 GooSeeker 开源爬虫的进一步发展指明方向：
谁来准备 URL？看来是Spider自己准备的，所以可以猜到Scrapy架构部分（不包括Spider）主要是用于事件调度的，与URL的存储无关。它看起来类似于 GooSeeker 会员中心的爬虫指南针。为目标网站准备一批URL，放入罗盘中，为爬虫调度操作做准备。所以，这个开源项目的下一个目标是将 URL 管理放在一个集中的调度库中。
看到这个其实挺难理解的，需要看一些其他的文档才能理解。继第一点之后，引擎从Spider获取URL后，将其封装成Request，交给事件循环，由Scheduler采集，进行调度管理。暂且理解为对Request进行排队。引擎现在查找调度程序接下来要下载的网页的地址。
从调度器申请任务，将申请的任务交给下载器。下载器和引擎之间有一个下载器中间件。这是开发框架的一个重要亮点。开发人员可以在这里进行一些自定义。延期。
下载完成后，会生成一个Response，通过下载器中间件交给引擎。请注意，Response 和前面的 Request 的首字母大写。虽然没看过其他的Scrapy文档，但我猜这是Scrapy框架内部的一个事件对象，也可以推断它是一个异步事件驱动的引擎，就像DS机器的三级事件循环，这对于高性能、低开销的引擎来说是必须的。
一个中间件再次出现，给了开发者足够的发挥空间。
每个蜘蛛按顺序爬取一个网页，当一个完成后，再构造一个Request事件，开始对另一个网页的爬取。
事件分发引擎。
连续运行。
4.接下来的工作
接下来，我们将进一步研究Scrapy的文档，实现Python即时网络爬虫与Scrapy的集成。
5.文档修改历史
2016-06-08：V1.0，首次发布
上一章爬取京东商品列表 下一章Scrapy入门方案回顾 查看全部
Scrapy，一个用 Python 开发的网页抓取框架。
1 简介
Python 即时网络爬虫最初的目标是把互联网变成一个大数据库。纯开源代码并不是开源的全部。开源的核心是“开放思维”，它聚合了最好的想法、技术和人才。所以会提到很多主导产品，比如Scrapy、ScrapingHub、Import.io等。
本文简要介绍了 Scrapy 的架构。是的，通用提取器 gsExtractor 将被集成到 Scrapy 架构中。
请注意，本文不想重复原文内容，而是为开源Python爬虫的发展方向寻找参考，并以近9年开发网络爬虫的经验为基准，所以这篇文章收录了作者的很多主观评论。如果想阅读Scrapy官方原文，请点击Scrapy官网架构。
2、Scrapy架构图
蜘蛛是为特定目标编写的内容提取器网站，这是通用网络爬虫框架中最可定制的部分。当你使用 Scrapy 创建爬虫项目时，会生成一个爬虫架。只需填写代码，根据其运行方式填写，即可融入到Scrapy的整体数据流中。Python实时网络爬虫开源项目的目标是节省程序员一半以上的时间。关键是提高Spider的定义和测试速度。解决方案见1分钟快速生成网页内容提取器，让整个Scrapy爬虫系统达到快速定制的目的。
3、Scrapy的数据流（Data Flow）
Scrapy 中的数据流由执行引擎控制。以下原文摘自 Scrapy 官网。我根据自己的猜测发表评论，为 GooSeeker 开源爬虫的进一步发展指明方向：
谁来准备 URL？看来是Spider自己准备的，所以可以猜到Scrapy架构部分（不包括Spider）主要是用于事件调度的，与URL的存储无关。它看起来类似于 GooSeeker 会员中心的爬虫指南针。为目标网站准备一批URL，放入罗盘中，为爬虫调度操作做准备。所以，这个开源项目的下一个目标是将 URL 管理放在一个集中的调度库中。
看到这个其实挺难理解的，需要看一些其他的文档才能理解。继第一点之后，引擎从Spider获取URL后，将其封装成Request，交给事件循环，由Scheduler采集，进行调度管理。暂且理解为对Request进行排队。引擎现在查找调度程序接下来要下载的网页的地址。
从调度器申请任务，将申请的任务交给下载器。下载器和引擎之间有一个下载器中间件。这是开发框架的一个重要亮点。开发人员可以在这里进行一些自定义。延期。
下载完成后，会生成一个Response，通过下载器中间件交给引擎。请注意，Response 和前面的 Request 的首字母大写。虽然没看过其他的Scrapy文档，但我猜这是Scrapy框架内部的一个事件对象，也可以推断它是一个异步事件驱动的引擎，就像DS机器的三级事件循环，这对于高性能、低开销的引擎来说是必须的。
一个中间件再次出现，给了开发者足够的发挥空间。
每个蜘蛛按顺序爬取一个网页，当一个完成后，再构造一个Request事件，开始对另一个网页的爬取。
事件分发引擎。
连续运行。
4.接下来的工作
接下来，我们将进一步研究Scrapy的文档，实现Python即时网络爬虫与Scrapy的集成。
5.文档修改历史
2016-06-08：V1.0，首次发布
上一章爬取京东商品列表 下一章Scrapy入门方案回顾 查看全部
scrapy分页抓取网页(Python开发的一个web抓取框架（上）|官网)
Scrapy，一个用 Python 开发的网页抓取框架。
1 简介
Python 即时网络爬虫最初的目标是把互联网变成一个大数据库。纯开源代码并不是开源的全部。开源的核心是“开放思维”，它聚合了最好的想法、技术和人才。所以会提到很多主导产品，比如Scrapy、ScrapingHub、Import.io等。
本文简要介绍了 Scrapy 的架构。是的，通用提取器 gsExtractor 将被集成到 Scrapy 架构中。
请注意，本文不想重复原文内容，而是为开源Python爬虫的发展方向寻找参考，并以近9年开发网络爬虫的经验为基准，所以这篇文章收录了作者的很多主观评论。如果想阅读Scrapy官方原文，请点击Scrapy官网架构。
2、Scrapy架构图
蜘蛛是为特定目标编写的内容提取器网站，这是通用网络爬虫框架中最可定制的部分。当你使用 Scrapy 创建爬虫项目时，会生成一个爬虫架。只需填写代码，根据其运行方式填写，即可融入到Scrapy的整体数据流中。Python实时网络爬虫开源项目的目标是节省程序员一半以上的时间。关键是提高Spider的定义和测试速度。解决方案见1分钟快速生成网页内容提取器，让整个Scrapy爬虫系统达到快速定制的目的。
3、Scrapy的数据流（Data Flow）
Scrapy 中的数据流由执行引擎控制。以下原文摘自 Scrapy 官网。我根据自己的猜测发表评论，为 GooSeeker 开源爬虫的进一步发展指明方向：
谁来准备 URL？看来是Spider自己准备的，所以可以猜到Scrapy架构部分（不包括Spider）主要是用于事件调度的，与URL的存储无关。它看起来类似于 GooSeeker 会员中心的爬虫指南针。为目标网站准备一批URL，放入罗盘中，为爬虫调度操作做准备。所以，这个开源项目的下一个目标是将 URL 管理放在一个集中的调度库中。
看到这个其实挺难理解的，需要看一些其他的文档才能理解。继第一点之后，引擎从Spider获取URL后，将其封装成Request，交给事件循环，由Scheduler采集，进行调度管理。暂且理解为对Request进行排队。引擎现在查找调度程序接下来要下载的网页的地址。
从调度器申请任务，将申请的任务交给下载器。下载器和引擎之间有一个下载器中间件。这是开发框架的一个重要亮点。开发人员可以在这里进行一些自定义。延期。
下载完成后，会生成一个Response，通过下载器中间件交给引擎。请注意，Response 和前面的 Request 的首字母大写。虽然没看过其他的Scrapy文档，但我猜这是Scrapy框架内部的一个事件对象，也可以推断它是一个异步事件驱动的引擎，就像DS机器的三级事件循环，这对于高性能、低开销的引擎来说是必须的。
一个中间件再次出现，给了开发者足够的发挥空间。
每个蜘蛛按顺序爬取一个网页，当一个完成后，再构造一个Request事件，开始对另一个网页的爬取。
事件分发引擎。
连续运行。
4.接下来的工作
接下来，我们将进一步研究Scrapy的文档，实现Python即时网络爬虫与Scrapy的集成。
5.文档修改历史
2016-06-08：V1.0，首次发布
上一章爬取京东商品列表 下一章Scrapy入门方案回顾
scrapy分页抓取网页( Scrapy的安装输入密码安装完成/scrapy.py)
网站优化 • 优采云 发表了文章 • 0 个评论 • 47 次浏览 • 2022-02-05 06:10
scrapy分页抓取网页(
Scrapy的安装输入密码安装完成/scrapy.py)
Scrapy入门教程——爬上iTunes应用列表
什么是刮痧？
Scrapy 是一个开源的基于 Twisted 的 Python 爬虫框架。我们只需要自定义几个简单的模块即可爬取网络数据。Scrapy的整体架构
简单解释一下上图：
爬虫处理的原材料是一个或多个url。爬取时，Sheduler 会为Downloader 分配一个url 进行网络请求请求。请求完成后，Downloader 会将获取到的响应传给 Spider。如果返回的数据是我们需要的，则将数据处理成对应的Item，交给ItemPipeline进行存储等处理。如果返回的url还是要处理的url，那么就必须交给Scheduler进行另一个处理过程。
3.Scrapy 的安装
sudo pip_install scrapy 或 sudo easy_intall scrapy
输入密码，安装完成。如果你使用scrapy，如果没有找不到命令，就说明安装成功了。
4.创建一个项目
scrapy startproject project_name
如果看到上面的提示，那么我们的项目就创建成功了。切换到项目目录，我们会看到如下目录结构
应用程序/
整个项目的scrapy.cfg配置信息
所有 python 自定义模块的 appScrapy/ 文件夹
初始化文件
items.py 数据结构保存爬取的数据
pipelines.py 数据流处理文件，对爬取的数据流进行处理
settings.py 设置文件，其中设置了数据库等
spiders/ 存储我们的自定义蜘蛛
初始化文件
…
让我们找到完整的目标，appStore的娱乐图表
我们要爬取的数据是列表中应用的名称及其对应的具体信息的url。
首先我们自定义我们用来保存数据类型的items.py，打开items.py，添加代码如下：
import scrapy
class AppscrapyItem(scrapy.Item):
# define the fields for your item here like:
name = scrapy.Field()
url = scrapy.Field()
简单来说，所有item都继承自scrapy.Item，里面的字段是scrapy.Field()类型，scrapy.Field()可以接收任何数据类型。
现在是时候自定义我们的爬虫了。
在 spiders 文件夹中创建一个 AppScrapy.py，然后打开并添加以下代码
from scrapy.spider import BaseSpider
from appScrapy.items import AppscrapyItem
class AppScrapy(BaseSpider):
name = ‘app_scrapy‘
start_urls = ["https://itunes.apple.com/cn/ge ... ot%3B]
def parse(self, response):
result = []
lis = response.xpath("//div[@class=‘grid3-column‘]/div")
for li in lis:
array = li.xpath("./ul/li")
for node in array:
item = AppscrapyItem()
item["name"] = node.xpath("./a/text()").extract()
item["url"] = node.xpath("./a/@href").extract()
result.append(item)
return result
所有的爬虫类都需要继承自BaseSpider，并且必须定义一个名字，因为我们需要用这个名字来启动爬虫。一个url数组，爬虫有必要知道它应该去哪里。最后，必须实现 parse 方法。在这里，爬回来的数据真的是经过过滤得到我们想要的。
当我们启动爬虫（scrapy crawl app_scrapy）时，scrapy会从start_urls中取第一个url，用这个url发起请求，并使用parse作为请求的回调函数，回调函数中的response就是request的response请求后收到。
对于内容的选择，我们使用 xpath 方法。xpath 方法需要输入路径并返回选择器数组。
对于路径，我们可以使用Chrome的开发者工具来获取，如上图。当我们要获取内容的时候，只要选择Element选项卡下的内容，然后右键选择copy xPath
lis = response.xpath("//div[@class=‘grid3-column‘]/div")
首先，我们使用xpath获取class = 'grid3-column'的div中的所有div，返回值是一个数组。从上图中我们可以看出，数组中应该有 3 个选择器代表 div。
每个 div 中的内容如上图所示。我们取出每个 div 并解析其内容。
for li in lis:
array = li.xpath("./ul/li")
for node in array:
item = AppscrapyItem()
item["name"] = node.xpath("./a/text()").extract()
item["url"] = node.xpath("./a/@href").extract()
result.append(item)
先用for循环取出每个div，然后获取当前div下所有ul下的所有li，如上图所示，我们会得到一个代表li的选择器数组。再来看看li的结构
中间的文本是通过text()获取的，所以当前li的文本路径是“./a/text()”“.” 表示当前选择器的开始。如果返回，xpath 返回一个选择器。如果我们想得到它的真实值，我们需要调用extract()，它会返回一个真实文字值的数组。
要获取字段的属性值，需要使用@，比如上面的@href，然后将这些值赋给我们写的item。
当然，数据应该保存，并且会继续。下次如何保存到数据库中。
时间：03-08
Scrapy入门教程--爬取iTunes应用列表相关文章Scrapy入门教程
在这个介绍性教程中，我们假设您已经安装了 Scrapy。如果没有，请参阅安装指南。我们将使用 Open Directory Project (dmoz) 作为抓取示例。本介绍性教程将引导您完成以下任务： 创建一个新的 Scrapy 项目以定义提取的项目 编写一个蜘蛛来爬取站点并提取项目 编写一个项目管道来存储提取的项目 Scrapy 是用 Python 编写的。如果您是 Python 新手，您可能希望从了解 Python 开始，以便最好地使用 Scrapy。如果你熟悉其他编程语言，想快速学习
Python的scrapy入门教程
看了这篇文章的同学，我假设大家都学过python（Pyson），那么下面的知识就是python的一个扩展（framework）。在这个介绍性教程中，我们假设您已经安装了 Scrapy。如果您还没有安装它，请参阅安装指南。我们将使用 Open Directory Project (dmoz) 作为抓取示例。本介绍性教程将指导您完成以下任务： 创建一个新的 Scrapy 项目，定义提取的项目 编写一个蜘蛛来抓取站点并提取项目 编写一个项目管道来存储提取的项目 Scrapy 是用 Python 编写的。如果你是皮思
开始使用 Scrapy
Scrapy 是一个用 Python 编写的应用程序框架，用于爬取 网站 数据并提取结构化数据。Scrapy 常用于数据挖掘、信息处理或存储历史数据等一系列程序中。通常我们通过 Scrapy 框架实现爬虫来抓取指定 网站 的内容或图片是非常简单的。Scrapy架构图（绿线为数据流） Scrapy Engine（引擎）：负责Spider.ItemPipeline.Downloader.Scheduler中间的通信、信号、数据传输等调度器：负责接收引擎
在 Scrapy 入门教程中写入数据库
那么前面的文章会讲到如何将抓取到的数据写入数据库。1. 爬虫脚本还是以爬虫百科为例，脚本编写保存在Hello/spiders目录下的spider_qiushibaike中。py 文件 # -*- 编码：utf-8 -*- import scrapy from Hello.items import HelloItem class Spider_qiush
Angular2 入门教程-2 实现 TodoList 应用
最近在学习中遇到一些问题（机械工业出版社），没看懂书上说的什么。我在网上找了一些，资源很多，也有很多以前的经验。原文： 原文地址：
Scrapy安装、爬虫入门教程、爬虫示例（豆瓣电影爬虫）
窗口上Scrapy的安装教程见以下链接： Scrapy安装教程 以上安装教程已经实践过，可行。本来打算在ubuntu上安装scrapy，但是ubuntu磁盘空间太小，还没有扩充磁盘空间，暂时不想再安装太多软件了。Scrapy的入门教程见以下链接： 上面的入门教程很基础。先跟随作者，动起来。不要只阅读上面的介绍性教程。这是一个简短的总结。我们来看看Scrapy爬虫流程：1.在Item中定义你要爬取的数据：movie_name就像字典中的“key”，爬取的数量
Scrapy 框架入门
Scrapy 入门教程 在本教程中，我已经安装了 Scrapy。本教程将带您完成以下任务： 创建一个 Scrapy 项目以定义提取的项目 编写一个爬取 网站 的蜘蛛并提取项目 编写一个项目管道来存储提取的项目（即数据） 创建一个项目 之前开始抓取，您必须创建一个新的 Scrapy 项目。转到您打算存储代码的目录并运行以下命令：scrapy startproject tutorial tutorial/ scrapy.cfg tutorial/ __init__
[scrapy] 开始学习Scrapy
Scrapy 简介 Scrapy 是一个用于爬取网站 数据并提取结构化数据的应用程序框架。它可用于数据挖掘、信息处理或历史数据存储等一系列程序中。所谓网络爬虫，就是在互联网上到处或有针对性地爬取数据的程序。当然，这种说法不够专业。更专业的描述是爬取特定网站网页的HTML数据。爬取网页的一般方法是定义一个条目。页面，然后一般一个页面会有其他页面的url，所以这些url是从当前页面获取的，加入爬虫的抓取队列，然后进入新页面，然后递归执行上述操作。实际上，它与深度有关，与遍历或广度遍历相同。屏幕截图
2015最新Android基础入门教程目录（汉化版）
2015最新Android基础入门教程目录（最终版） 标签（空格分隔）：Android基础入门教程 前言：关于今天终于结束了，全套教程一共写了148节，附目录，关于教程的由来，作者的情况和自学经验，资源分享以及一些问题可以戳：成品散花~以下是本系列教程的完整目录：第一章：环境搭建与开发（ 10月1日完成0)Android Basic入门教程--1.1背景及系统架构 查看全部
Scrapy的安装输入密码安装完成/scrapy.py)
Scrapy入门教程——爬上iTunes应用列表
什么是刮痧？
Scrapy 是一个开源的基于 Twisted 的 Python 爬虫框架。我们只需要自定义几个简单的模块即可爬取网络数据。Scrapy的整体架构
简单解释一下上图：
爬虫处理的原材料是一个或多个url。爬取时，Sheduler 会为Downloader 分配一个url 进行网络请求请求。请求完成后，Downloader 会将获取到的响应传给 Spider。如果返回的数据是我们需要的，则将数据处理成对应的Item，交给ItemPipeline进行存储等处理。如果返回的url还是要处理的url，那么就必须交给Scheduler进行另一个处理过程。
3.Scrapy 的安装
sudo pip_install scrapy 或 sudo easy_intall scrapy
输入密码，安装完成。如果你使用scrapy，如果没有找不到命令，就说明安装成功了。
4.创建一个项目
scrapy startproject project_name
如果看到上面的提示，那么我们的项目就创建成功了。切换到项目目录，我们会看到如下目录结构
应用程序/
整个项目的scrapy.cfg配置信息
所有 python 自定义模块的 appScrapy/ 文件夹
初始化文件
items.py 数据结构保存爬取的数据
pipelines.py 数据流处理文件，对爬取的数据流进行处理
settings.py 设置文件，其中设置了数据库等
spiders/ 存储我们的自定义蜘蛛
初始化文件
…
让我们找到完整的目标，appStore的娱乐图表
我们要爬取的数据是列表中应用的名称及其对应的具体信息的url。
首先我们自定义我们用来保存数据类型的items.py，打开items.py，添加代码如下：
import scrapy
class AppscrapyItem(scrapy.Item):
# define the fields for your item here like:
name = scrapy.Field()
url = scrapy.Field()
简单来说，所有item都继承自scrapy.Item，里面的字段是scrapy.Field()类型，scrapy.Field()可以接收任何数据类型。
现在是时候自定义我们的爬虫了。
在 spiders 文件夹中创建一个 AppScrapy.py，然后打开并添加以下代码
from scrapy.spider import BaseSpider
from appScrapy.items import AppscrapyItem
class AppScrapy(BaseSpider):
name = ‘app_scrapy‘
start_urls = ["https://itunes.apple.com/cn/ge ... ot%3B]
def parse(self, response):
result = []
lis = response.xpath("//div[@class=‘grid3-column‘]/div")
for li in lis:
array = li.xpath("./ul/li")
for node in array:
item = AppscrapyItem()
item["name"] = node.xpath("./a/text()").extract()
item["url"] = node.xpath("./a/@href").extract()
result.append(item)
return result
所有的爬虫类都需要继承自BaseSpider，并且必须定义一个名字，因为我们需要用这个名字来启动爬虫。一个url数组，爬虫有必要知道它应该去哪里。最后，必须实现 parse 方法。在这里，爬回来的数据真的是经过过滤得到我们想要的。
当我们启动爬虫（scrapy crawl app_scrapy）时，scrapy会从start_urls中取第一个url，用这个url发起请求，并使用parse作为请求的回调函数，回调函数中的response就是request的response请求后收到。
对于内容的选择，我们使用 xpath 方法。xpath 方法需要输入路径并返回选择器数组。
对于路径，我们可以使用Chrome的开发者工具来获取，如上图。当我们要获取内容的时候，只要选择Element选项卡下的内容，然后右键选择copy xPath
lis = response.xpath("//div[@class=‘grid3-column‘]/div")
首先，我们使用xpath获取class = 'grid3-column'的div中的所有div，返回值是一个数组。从上图中我们可以看出，数组中应该有 3 个选择器代表 div。
每个 div 中的内容如上图所示。我们取出每个 div 并解析其内容。
for li in lis:
array = li.xpath("./ul/li")
for node in array:
item = AppscrapyItem()
item["name"] = node.xpath("./a/text()").extract()
item["url"] = node.xpath("./a/@href").extract()
result.append(item)
先用for循环取出每个div，然后获取当前div下所有ul下的所有li，如上图所示，我们会得到一个代表li的选择器数组。再来看看li的结构
中间的文本是通过text()获取的，所以当前li的文本路径是“./a/text()”“.” 表示当前选择器的开始。如果返回，xpath 返回一个选择器。如果我们想得到它的真实值，我们需要调用extract()，它会返回一个真实文字值的数组。
要获取字段的属性值，需要使用@，比如上面的@href，然后将这些值赋给我们写的item。
当然，数据应该保存，并且会继续。下次如何保存到数据库中。
时间：03-08
Scrapy入门教程--爬取iTunes应用列表相关文章Scrapy入门教程
在这个介绍性教程中，我们假设您已经安装了 Scrapy。如果没有，请参阅安装指南。我们将使用 Open Directory Project (dmoz) 作为抓取示例。本介绍性教程将引导您完成以下任务： 创建一个新的 Scrapy 项目以定义提取的项目 编写一个蜘蛛来爬取站点并提取项目 编写一个项目管道来存储提取的项目 Scrapy 是用 Python 编写的。如果您是 Python 新手，您可能希望从了解 Python 开始，以便最好地使用 Scrapy。如果你熟悉其他编程语言，想快速学习
Python的scrapy入门教程
看了这篇文章的同学，我假设大家都学过python（Pyson），那么下面的知识就是python的一个扩展（framework）。在这个介绍性教程中，我们假设您已经安装了 Scrapy。如果您还没有安装它，请参阅安装指南。我们将使用 Open Directory Project (dmoz) 作为抓取示例。本介绍性教程将指导您完成以下任务： 创建一个新的 Scrapy 项目，定义提取的项目 编写一个蜘蛛来抓取站点并提取项目 编写一个项目管道来存储提取的项目 Scrapy 是用 Python 编写的。如果你是皮思
开始使用 Scrapy
Scrapy 是一个用 Python 编写的应用程序框架，用于爬取 网站 数据并提取结构化数据。Scrapy 常用于数据挖掘、信息处理或存储历史数据等一系列程序中。通常我们通过 Scrapy 框架实现爬虫来抓取指定 网站 的内容或图片是非常简单的。Scrapy架构图（绿线为数据流） Scrapy Engine（引擎）：负责Spider.ItemPipeline.Downloader.Scheduler中间的通信、信号、数据传输等调度器：负责接收引擎
在 Scrapy 入门教程中写入数据库
那么前面的文章会讲到如何将抓取到的数据写入数据库。1. 爬虫脚本还是以爬虫百科为例，脚本编写保存在Hello/spiders目录下的spider_qiushibaike中。py 文件 # -*- 编码：utf-8 -*- import scrapy from Hello.items import HelloItem class Spider_qiush
Angular2 入门教程-2 实现 TodoList 应用
最近在学习中遇到一些问题（机械工业出版社），没看懂书上说的什么。我在网上找了一些，资源很多，也有很多以前的经验。原文： 原文地址：
Scrapy安装、爬虫入门教程、爬虫示例（豆瓣电影爬虫）
窗口上Scrapy的安装教程见以下链接： Scrapy安装教程 以上安装教程已经实践过，可行。本来打算在ubuntu上安装scrapy，但是ubuntu磁盘空间太小，还没有扩充磁盘空间，暂时不想再安装太多软件了。Scrapy的入门教程见以下链接： 上面的入门教程很基础。先跟随作者，动起来。不要只阅读上面的介绍性教程。这是一个简短的总结。我们来看看Scrapy爬虫流程：1.在Item中定义你要爬取的数据：movie_name就像字典中的“key”，爬取的数量
Scrapy 框架入门
Scrapy 入门教程 在本教程中，我已经安装了 Scrapy。本教程将带您完成以下任务： 创建一个 Scrapy 项目以定义提取的项目 编写一个爬取 网站 的蜘蛛并提取项目 编写一个项目管道来存储提取的项目（即数据） 创建一个项目 之前开始抓取，您必须创建一个新的 Scrapy 项目。转到您打算存储代码的目录并运行以下命令：scrapy startproject tutorial tutorial/ scrapy.cfg tutorial/ __init__
[scrapy] 开始学习Scrapy
Scrapy 简介 Scrapy 是一个用于爬取网站 数据并提取结构化数据的应用程序框架。它可用于数据挖掘、信息处理或历史数据存储等一系列程序中。所谓网络爬虫，就是在互联网上到处或有针对性地爬取数据的程序。当然，这种说法不够专业。更专业的描述是爬取特定网站网页的HTML数据。爬取网页的一般方法是定义一个条目。页面，然后一般一个页面会有其他页面的url，所以这些url是从当前页面获取的，加入爬虫的抓取队列，然后进入新页面，然后递归执行上述操作。实际上，它与深度有关，与遍历或广度遍历相同。屏幕截图
2015最新Android基础入门教程目录（汉化版）
2015最新Android基础入门教程目录（最终版） 标签（空格分隔）：Android基础入门教程 前言：关于今天终于结束了，全套教程一共写了148节，附目录，关于教程的由来，作者的情况和自学经验，资源分享以及一些问题可以戳：成品散花~以下是本系列教程的完整目录：第一章：环境搭建与开发（ 10月1日完成0)Android Basic入门教程--1.1背景及系统架构 查看全部
scrapy分页抓取网页(
Scrapy的安装输入密码安装完成/scrapy.py)
Scrapy入门教程——爬上iTunes应用列表
什么是刮痧？
Scrapy 是一个开源的基于 Twisted 的 Python 爬虫框架。我们只需要自定义几个简单的模块即可爬取网络数据。Scrapy的整体架构
简单解释一下上图：
爬虫处理的原材料是一个或多个url。爬取时，Sheduler 会为Downloader 分配一个url 进行网络请求请求。请求完成后，Downloader 会将获取到的响应传给 Spider。如果返回的数据是我们需要的，则将数据处理成对应的Item，交给ItemPipeline进行存储等处理。如果返回的url还是要处理的url，那么就必须交给Scheduler进行另一个处理过程。
3.Scrapy 的安装
sudo pip_install scrapy 或 sudo easy_intall scrapy
输入密码，安装完成。如果你使用scrapy，如果没有找不到命令，就说明安装成功了。
4.创建一个项目
scrapy startproject project_name
如果看到上面的提示，那么我们的项目就创建成功了。切换到项目目录，我们会看到如下目录结构
应用程序/
整个项目的scrapy.cfg配置信息
所有 python 自定义模块的 appScrapy/ 文件夹
初始化文件
items.py 数据结构保存爬取的数据
pipelines.py 数据流处理文件，对爬取的数据流进行处理
settings.py 设置文件，其中设置了数据库等
spiders/ 存储我们的自定义蜘蛛
初始化文件
…
让我们找到完整的目标，appStore的娱乐图表
我们要爬取的数据是列表中应用的名称及其对应的具体信息的url。
首先我们自定义我们用来保存数据类型的items.py，打开items.py，添加代码如下：
import scrapy
class AppscrapyItem(scrapy.Item):
# define the fields for your item here like:
name = scrapy.Field()
url = scrapy.Field()
简单来说，所有item都继承自scrapy.Item，里面的字段是scrapy.Field()类型，scrapy.Field()可以接收任何数据类型。
现在是时候自定义我们的爬虫了。
在 spiders 文件夹中创建一个 AppScrapy.py，然后打开并添加以下代码
from scrapy.spider import BaseSpider
from appScrapy.items import AppscrapyItem
class AppScrapy(BaseSpider):
name = ‘app_scrapy‘
start_urls = ["https://itunes.apple.com/cn/ge ... ot%3B]
def parse(self, response):
result = []
lis = response.xpath("//div[@class=‘grid3-column‘]/div")
for li in lis:
array = li.xpath("./ul/li")
for node in array:
item = AppscrapyItem()
item["name"] = node.xpath("./a/text()").extract()
item["url"] = node.xpath("./a/@href").extract()
result.append(item)
return result
所有的爬虫类都需要继承自BaseSpider，并且必须定义一个名字，因为我们需要用这个名字来启动爬虫。一个url数组，爬虫有必要知道它应该去哪里。最后，必须实现 parse 方法。在这里，爬回来的数据真的是经过过滤得到我们想要的。
当我们启动爬虫（scrapy crawl app_scrapy）时，scrapy会从start_urls中取第一个url，用这个url发起请求，并使用parse作为请求的回调函数，回调函数中的response就是request的response请求后收到。
对于内容的选择，我们使用 xpath 方法。xpath 方法需要输入路径并返回选择器数组。
对于路径，我们可以使用Chrome的开发者工具来获取，如上图。当我们要获取内容的时候，只要选择Element选项卡下的内容，然后右键选择copy xPath
lis = response.xpath("//div[@class=‘grid3-column‘]/div")
首先，我们使用xpath获取class = 'grid3-column'的div中的所有div，返回值是一个数组。从上图中我们可以看出，数组中应该有 3 个选择器代表 div。
每个 div 中的内容如上图所示。我们取出每个 div 并解析其内容。
for li in lis:
array = li.xpath("./ul/li")
for node in array:
item = AppscrapyItem()
item["name"] = node.xpath("./a/text()").extract()
item["url"] = node.xpath("./a/@href").extract()
result.append(item)
先用for循环取出每个div，然后获取当前div下所有ul下的所有li，如上图所示，我们会得到一个代表li的选择器数组。再来看看li的结构
中间的文本是通过text()获取的，所以当前li的文本路径是“./a/text()”“.” 表示当前选择器的开始。如果返回，xpath 返回一个选择器。如果我们想得到它的真实值，我们需要调用extract()，它会返回一个真实文字值的数组。
要获取字段的属性值，需要使用@，比如上面的@href，然后将这些值赋给我们写的item。
当然，数据应该保存，并且会继续。下次如何保存到数据库中。
时间：03-08
Scrapy入门教程--爬取iTunes应用列表相关文章Scrapy入门教程
在这个介绍性教程中，我们假设您已经安装了 Scrapy。如果没有，请参阅安装指南。我们将使用 Open Directory Project (dmoz) 作为抓取示例。本介绍性教程将引导您完成以下任务： 创建一个新的 Scrapy 项目以定义提取的项目 编写一个蜘蛛来爬取站点并提取项目 编写一个项目管道来存储提取的项目 Scrapy 是用 Python 编写的。如果您是 Python 新手，您可能希望从了解 Python 开始，以便最好地使用 Scrapy。如果你熟悉其他编程语言，想快速学习
Python的scrapy入门教程
看了这篇文章的同学，我假设大家都学过python（Pyson），那么下面的知识就是python的一个扩展（framework）。在这个介绍性教程中，我们假设您已经安装了 Scrapy。如果您还没有安装它，请参阅安装指南。我们将使用 Open Directory Project (dmoz) 作为抓取示例。本介绍性教程将指导您完成以下任务： 创建一个新的 Scrapy 项目，定义提取的项目 编写一个蜘蛛来抓取站点并提取项目 编写一个项目管道来存储提取的项目 Scrapy 是用 Python 编写的。如果你是皮思
开始使用 Scrapy
Scrapy 是一个用 Python 编写的应用程序框架，用于爬取 网站 数据并提取结构化数据。Scrapy 常用于数据挖掘、信息处理或存储历史数据等一系列程序中。通常我们通过 Scrapy 框架实现爬虫来抓取指定 网站 的内容或图片是非常简单的。Scrapy架构图（绿线为数据流） Scrapy Engine（引擎）：负责Spider.ItemPipeline.Downloader.Scheduler中间的通信、信号、数据传输等调度器：负责接收引擎
在 Scrapy 入门教程中写入数据库
那么前面的文章会讲到如何将抓取到的数据写入数据库。1. 爬虫脚本还是以爬虫百科为例，脚本编写保存在Hello/spiders目录下的spider_qiushibaike中。py 文件 # -*- 编码：utf-8 -*- import scrapy from Hello.items import HelloItem class Spider_qiush
Angular2 入门教程-2 实现 TodoList 应用
最近在学习中遇到一些问题（机械工业出版社），没看懂书上说的什么。我在网上找了一些，资源很多，也有很多以前的经验。原文： 原文地址：
Scrapy安装、爬虫入门教程、爬虫示例（豆瓣电影爬虫）
窗口上Scrapy的安装教程见以下链接： Scrapy安装教程 以上安装教程已经实践过，可行。本来打算在ubuntu上安装scrapy，但是ubuntu磁盘空间太小，还没有扩充磁盘空间，暂时不想再安装太多软件了。Scrapy的入门教程见以下链接： 上面的入门教程很基础。先跟随作者，动起来。不要只阅读上面的介绍性教程。这是一个简短的总结。我们来看看Scrapy爬虫流程：1.在Item中定义你要爬取的数据：movie_name就像字典中的“key”，爬取的数量
Scrapy 框架入门
Scrapy 入门教程 在本教程中，我已经安装了 Scrapy。本教程将带您完成以下任务： 创建一个 Scrapy 项目以定义提取的项目 编写一个爬取 网站 的蜘蛛并提取项目 编写一个项目管道来存储提取的项目（即数据） 创建一个项目 之前开始抓取，您必须创建一个新的 Scrapy 项目。转到您打算存储代码的目录并运行以下命令：scrapy startproject tutorial tutorial/ scrapy.cfg tutorial/ __init__
[scrapy] 开始学习Scrapy
Scrapy 简介 Scrapy 是一个用于爬取网站 数据并提取结构化数据的应用程序框架。它可用于数据挖掘、信息处理或历史数据存储等一系列程序中。所谓网络爬虫，就是在互联网上到处或有针对性地爬取数据的程序。当然，这种说法不够专业。更专业的描述是爬取特定网站网页的HTML数据。爬取网页的一般方法是定义一个条目。页面，然后一般一个页面会有其他页面的url，所以这些url是从当前页面获取的，加入爬虫的抓取队列，然后进入新页面，然后递归执行上述操作。实际上，它与深度有关，与遍历或广度遍历相同。屏幕截图
2015最新Android基础入门教程目录（汉化版）
2015最新Android基础入门教程目录（最终版） 标签（空格分隔）：Android基础入门教程 前言：关于今天终于结束了，全套教程一共写了148节，附目录，关于教程的由来，作者的情况和自学经验，资源分享以及一些问题可以戳：成品散花~以下是本系列教程的完整目录：第一章：环境搭建与开发（ 10月1日完成0)Android Basic入门教程--1.1背景及系统架构
scrapy分页抓取网页(国内docker仓库镜像对比安装运行Splash.jsJS渲染解析 )
网站优化 • 优采云 发表了文章 • 0 个评论 • 48 次浏览 • 2022-02-03 18:01
scrapy分页抓取网页(国内docker仓库镜像对比安装运行Splash.jsJS渲染解析
)
随着越来越多的网站开始在客户端浏览器中使用JS动态渲染网站，很多我们需要的数据无法从原创html中获取，加上Scrapy不提供JS渲染和解析的功能。通常，我们一般使用两种方法来爬取这种类型的网站数据：
通过分析网站，找到数据对应的接口，模拟接口获取我们需要的数据（见Scrapy抓取Ajax动态页面），但是一旦网站的接口被隐藏深入，或者接口的加密太复杂，这种方法可能行不通。在JS内核的帮助下，将得到的收录JS脚本的页面交给JS内核进行渲染，最后将渲染后生成的html返回给Scrapy进行分析，这是比较常见的WebKit和Scrapy-Splash
本文文章的目的是介绍如何使用Scrapy-Splash用Scrapy爬取动态页面。
准备
Docker安装，具体安装步骤请参考Docker官网
为什么要安装 Docker？
由于Scrapy-Splash使用Splash HTTP API，需要提供Splash实例，并且Docker镜像中已经存在Splash实例，可以方便的使用。
Docker镜像源变更，参考国内docker仓库镜像对比
安装并运行 Splash
docker pull scrapinghub/splash #从docker镜像中拉取splash实例
docker run -p 8050:8050 scrapinghub/splash #启动splash实例
Scrapy 配置
在 Scrapy 项目的 setting.py 中添加以下内容：
SPLASH_URL = 'http://localhost:8050'
DOWNLOADER_MIDDLEWARES = {
'scrapy_splash.SplashCookiesMiddleware': 723,
'scrapy_splash.SplashMiddleware': 725,
'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 810,
}
SPIDER_MIDDLEWARES = {
'scrapy_splash.SplashDeduplicateArgsMiddleware': 100,
}
DUPEFILTER_CLASS = 'scrapy_splash.SplashAwareDupeFilter'
HTTPCACHE_STORAGE = 'scrapy_splash.SplashAwareFSCacheStorage'
实际代码分析
我们以腾讯证券页面为例。腾讯证券新闻列表是js动态渲染的
我们直接打开这个链接，然后打开开发者工具，找到新闻列表：
当我们查看网络第一个请求的Response时，发现返回的html中的列表页是空的
实际数据隐藏在JS中，加载完成后通过JS操作完成DOM插入
因为这里实际数据是塞进了一个JS变量中，并不是通过Ajax调用接口获取的，所以为了避免手动拦截JS变量，我们将页面交给Scrapy-Splash进行渲染
import scrapy
from FinancialInfoSpider.items import ArticleItem
from scrapy_splash import SplashRequest
from w3lib.html import remove_tags
import re
from bs4 import BeautifulSoup
class TencentStockSpider(scrapy.Spider):
name = "TencentStock"
def start_requests(self):
urls = [
'http://stock.qq.com/l/stock/yw ... 39%3B,
]
for url in urls:
yield SplashRequest(url, self.parse, args={'wait': 0.5})
def parse(self,response):
sel = scrapy.Selector(response)
links = sel.xpath("//div[@class='qq_main']//ul[@class='listInfo']//li//div[@class='info']//h3//a/@href").extract()
requests = []
for link in links:
request = scrapy.Request(link, callback =self.parse_article)
requests.append(request)
return requests
def parse_article(self,response):
sel = scrapy.Selector(response)
article = ArticleItem()
article['title'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/h1/text()').extract()[0]
article['source'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/div/div[1]/span[2]').xpath('string(.)').extract()[0]
article['pub_time'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/div/div[1]/span[3]/text()').extract()[0]
html_content = sel.xpath('//*[@id="Cnt-Main-Article-QQ"]').extract()[0]
article['content'] = self.remove_html_tags(html_content)
return article
def remove_html_tags(self,html):
soup = BeautifulSoup(html)
[s.extract() for s in soup('script')]
[s.extract() for s in soup('style')]
content = ''
for substring in soup.stripped_strings:
content = content + substring
return content
主要代码就一句话，将获取的页面发送到本地Splash实例进行渲染解析，最后将结果返回给parse函数进行解析
SplashRequest(url, self.parse, args={'wait': 0.5})
BeautifulSoup 库用于去除 html 中的 script 和 style 标签。具体用法可以参考这两篇文章文章：
Python爬虫第二把武器Beautiful Soup的用法
使用 BeautifulSoup 删除 html 中的脚本和注释
输出结果：
查看全部
)
随着越来越多的网站开始在客户端浏览器中使用JS动态渲染网站，很多我们需要的数据无法从原创html中获取，加上Scrapy不提供JS渲染和解析的功能。通常，我们一般使用两种方法来爬取这种类型的网站数据：
通过分析网站，找到数据对应的接口，模拟接口获取我们需要的数据（见Scrapy抓取Ajax动态页面），但是一旦网站的接口被隐藏深入，或者接口的加密太复杂，这种方法可能行不通。在JS内核的帮助下，将得到的收录JS脚本的页面交给JS内核进行渲染，最后将渲染后生成的html返回给Scrapy进行分析，这是比较常见的WebKit和Scrapy-Splash
本文文章的目的是介绍如何使用Scrapy-Splash用Scrapy爬取动态页面。
准备
Docker安装，具体安装步骤请参考Docker官网
为什么要安装 Docker？
由于Scrapy-Splash使用Splash HTTP API，需要提供Splash实例，并且Docker镜像中已经存在Splash实例，可以方便的使用。
Docker镜像源变更，参考国内docker仓库镜像对比
安装并运行 Splash
docker pull scrapinghub/splash #从docker镜像中拉取splash实例
docker run -p 8050:8050 scrapinghub/splash #启动splash实例
Scrapy 配置
在 Scrapy 项目的 setting.py 中添加以下内容：
SPLASH_URL = 'http://localhost:8050'
DOWNLOADER_MIDDLEWARES = {
'scrapy_splash.SplashCookiesMiddleware': 723,
'scrapy_splash.SplashMiddleware': 725,
'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 810,
}
SPIDER_MIDDLEWARES = {
'scrapy_splash.SplashDeduplicateArgsMiddleware': 100,
}
DUPEFILTER_CLASS = 'scrapy_splash.SplashAwareDupeFilter'
HTTPCACHE_STORAGE = 'scrapy_splash.SplashAwareFSCacheStorage'
实际代码分析
我们以腾讯证券页面为例。腾讯证券新闻列表是js动态渲染的
我们直接打开这个链接，然后打开开发者工具，找到新闻列表：
当我们查看网络第一个请求的Response时，发现返回的html中的列表页是空的
实际数据隐藏在JS中，加载完成后通过JS操作完成DOM插入
因为这里实际数据是塞进了一个JS变量中，并不是通过Ajax调用接口获取的，所以为了避免手动拦截JS变量，我们将页面交给Scrapy-Splash进行渲染
import scrapy
from FinancialInfoSpider.items import ArticleItem
from scrapy_splash import SplashRequest
from w3lib.html import remove_tags
import re
from bs4 import BeautifulSoup
class TencentStockSpider(scrapy.Spider):
name = "TencentStock"
def start_requests(self):
urls = [
'http://stock.qq.com/l/stock/yw ... 39%3B,
]
for url in urls:
yield SplashRequest(url, self.parse, args={'wait': 0.5})
def parse(self,response):
sel = scrapy.Selector(response)
links = sel.xpath("//div[@class='qq_main']//ul[@class='listInfo']//li//div[@class='info']//h3//a/@href").extract()
requests = []
for link in links:
request = scrapy.Request(link, callback =self.parse_article)
requests.append(request)
return requests
def parse_article(self,response):
sel = scrapy.Selector(response)
article = ArticleItem()
article['title'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/h1/text()').extract()[0]
article['source'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/div/div[1]/span[2]').xpath('string(.)').extract()[0]
article['pub_time'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/div/div[1]/span[3]/text()').extract()[0]
html_content = sel.xpath('//*[@id="Cnt-Main-Article-QQ"]').extract()[0]
article['content'] = self.remove_html_tags(html_content)
return article
def remove_html_tags(self,html):
soup = BeautifulSoup(html)
[s.extract() for s in soup('script')]
[s.extract() for s in soup('style')]
content = ''
for substring in soup.stripped_strings:
content = content + substring
return content
主要代码就一句话，将获取的页面发送到本地Splash实例进行渲染解析，最后将结果返回给parse函数进行解析
SplashRequest(url, self.parse, args={'wait': 0.5})
BeautifulSoup 库用于去除 html 中的 script 和 style 标签。具体用法可以参考这两篇文章文章：
Python爬虫第二把武器Beautiful Soup的用法
使用 BeautifulSoup 删除 html 中的脚本和注释
输出结果：
查看全部
scrapy分页抓取网页(国内docker仓库镜像对比安装运行Splash.jsJS渲染解析
)
随着越来越多的网站开始在客户端浏览器中使用JS动态渲染网站，很多我们需要的数据无法从原创html中获取，加上Scrapy不提供JS渲染和解析的功能。通常，我们一般使用两种方法来爬取这种类型的网站数据：
通过分析网站，找到数据对应的接口，模拟接口获取我们需要的数据（见Scrapy抓取Ajax动态页面），但是一旦网站的接口被隐藏深入，或者接口的加密太复杂，这种方法可能行不通。在JS内核的帮助下，将得到的收录JS脚本的页面交给JS内核进行渲染，最后将渲染后生成的html返回给Scrapy进行分析，这是比较常见的WebKit和Scrapy-Splash
本文文章的目的是介绍如何使用Scrapy-Splash用Scrapy爬取动态页面。
准备
Docker安装，具体安装步骤请参考Docker官网
为什么要安装 Docker？
由于Scrapy-Splash使用Splash HTTP API，需要提供Splash实例，并且Docker镜像中已经存在Splash实例，可以方便的使用。
Docker镜像源变更，参考国内docker仓库镜像对比
安装并运行 Splash
docker pull scrapinghub/splash #从docker镜像中拉取splash实例
docker run -p 8050:8050 scrapinghub/splash #启动splash实例
Scrapy 配置
在 Scrapy 项目的 setting.py 中添加以下内容：
SPLASH_URL = 'http://localhost:8050'
DOWNLOADER_MIDDLEWARES = {
'scrapy_splash.SplashCookiesMiddleware': 723,
'scrapy_splash.SplashMiddleware': 725,
'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 810,
}
SPIDER_MIDDLEWARES = {
'scrapy_splash.SplashDeduplicateArgsMiddleware': 100,
}
DUPEFILTER_CLASS = 'scrapy_splash.SplashAwareDupeFilter'
HTTPCACHE_STORAGE = 'scrapy_splash.SplashAwareFSCacheStorage'
实际代码分析
我们以腾讯证券页面为例。腾讯证券新闻列表是js动态渲染的
我们直接打开这个链接，然后打开开发者工具，找到新闻列表：
当我们查看网络第一个请求的Response时，发现返回的html中的列表页是空的
实际数据隐藏在JS中，加载完成后通过JS操作完成DOM插入
因为这里实际数据是塞进了一个JS变量中，并不是通过Ajax调用接口获取的，所以为了避免手动拦截JS变量，我们将页面交给Scrapy-Splash进行渲染
import scrapy
from FinancialInfoSpider.items import ArticleItem
from scrapy_splash import SplashRequest
from w3lib.html import remove_tags
import re
from bs4 import BeautifulSoup
class TencentStockSpider(scrapy.Spider):
name = "TencentStock"
def start_requests(self):
urls = [
'http://stock.qq.com/l/stock/yw ... 39%3B,
]
for url in urls:
yield SplashRequest(url, self.parse, args={'wait': 0.5})
def parse(self,response):
sel = scrapy.Selector(response)
links = sel.xpath("//div[@class='qq_main']//ul[@class='listInfo']//li//div[@class='info']//h3//a/@href").extract()
requests = []
for link in links:
request = scrapy.Request(link, callback =self.parse_article)
requests.append(request)
return requests
def parse_article(self,response):
sel = scrapy.Selector(response)
article = ArticleItem()
article['title'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/h1/text()').extract()[0]
article['source'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/div/div[1]/span[2]').xpath('string(.)').extract()[0]
article['pub_time'] = sel.xpath('//*[@id="Main-Article-QQ"]/div/div[1]/div[1]/div[1]/div/div[1]/span[3]/text()').extract()[0]
html_content = sel.xpath('//*[@id="Cnt-Main-Article-QQ"]').extract()[0]
article['content'] = self.remove_html_tags(html_content)
return article
def remove_html_tags(self,html):
soup = BeautifulSoup(html)
[s.extract() for s in soup('script')]
[s.extract() for s in soup('style')]
content = ''
for substring in soup.stripped_strings:
content = content + substring
return content
主要代码就一句话，将获取的页面发送到本地Splash实例进行渲染解析，最后将结果返回给parse函数进行解析
SplashRequest(url, self.parse, args={'wait': 0.5})
BeautifulSoup 库用于去除 html 中的 script 和 style 标签。具体用法可以参考这两篇文章文章：
Python爬虫第二把武器Beautiful Soup的用法
使用 BeautifulSoup 删除 html 中的脚本和注释
输出结果：
scrapy分页抓取网页(内建函数parseRequest请求获取新网页内容进一步处理，获爬取处理)
网站优化 • 优采云 发表了文章 • 0 个评论 • 48 次浏览 • 2022-02-03 17:28
scrapy分页抓取网页(内建函数parseRequest请求获取新网页内容进一步处理，获爬取处理)
因为最初抓取的网站是一个href，所以需要跳转到它，也就是发送一个Request
你好
这是我的代码：
def parse(self, response):
href_set = []
list = response.xpath("//div[@style='display:none;']//li/a/@href").extract() #获取href
for i in range(0, 50, 1): # 留下前50条数据
href_set.append(list[i])
for href in href_set:
yield scrapy.Request(url=href, callback=self.new_parse)
#就是这个Request请求了一个新的url，完成之后回调new_parse函数，进一步处理
def new_parse(self, response):
myitem = TutorialItem()
myitem['article_title'] = response.xpath("//h1[@class='main-title']/text()").extract()
myitem['article_content'] = response.xpath("//div[@class='article']//p/text()").extract()
# 获取第一张图片，可能无图
myitem['article_image'] = response.xpath("//div[@class='img_wrapper']//img/@src").extract_first()
# 把自己的item抛出给pipeline
yield myitem
总体思路是通过parse的自动调用获取href，然后使用Request请求获取新的网页内容进行进一步处理。
如果要爬取的网页有n层href，则调用Request n次，直到爬取到要获取数据的网页，否则保持Request和跳转访问（我的只有一层）href，即调整href一次）
其实内置函数parse的原理是类似的 查看全部
因为最初抓取的网站是一个href，所以需要跳转到它，也就是发送一个Request
你好
这是我的代码：
def parse(self, response):
href_set = []
list = response.xpath("//div[@style='display:none;']//li/a/@href").extract() #获取href
for i in range(0, 50, 1): # 留下前50条数据
href_set.append(list[i])
for href in href_set:
yield scrapy.Request(url=href, callback=self.new_parse)
#就是这个Request请求了一个新的url，完成之后回调new_parse函数，进一步处理
def new_parse(self, response):
myitem = TutorialItem()
myitem['article_title'] = response.xpath("//h1[@class='main-title']/text()").extract()
myitem['article_content'] = response.xpath("//div[@class='article']//p/text()").extract()
# 获取第一张图片，可能无图
myitem['article_image'] = response.xpath("//div[@class='img_wrapper']//img/@src").extract_first()
# 把自己的item抛出给pipeline
yield myitem
总体思路是通过parse的自动调用获取href，然后使用Request请求获取新的网页内容进行进一步处理。
如果要爬取的网页有n层href，则调用Request n次，直到爬取到要获取数据的网页，否则保持Request和跳转访问（我的只有一层）href，即调整href一次）
其实内置函数parse的原理是类似的 查看全部
scrapy分页抓取网页(内建函数parseRequest请求获取新网页内容进一步处理，获爬取处理)
因为最初抓取的网站是一个href，所以需要跳转到它，也就是发送一个Request
你好
这是我的代码：
def parse(self, response):
href_set = []
list = response.xpath("//div[@style='display:none;']//li/a/@href").extract() #获取href
for i in range(0, 50, 1): # 留下前50条数据
href_set.append(list[i])
for href in href_set:
yield scrapy.Request(url=href, callback=self.new_parse)
#就是这个Request请求了一个新的url，完成之后回调new_parse函数，进一步处理
def new_parse(self, response):
myitem = TutorialItem()
myitem['article_title'] = response.xpath("//h1[@class='main-title']/text()").extract()
myitem['article_content'] = response.xpath("//div[@class='article']//p/text()").extract()
# 获取第一张图片，可能无图
myitem['article_image'] = response.xpath("//div[@class='img_wrapper']//img/@src").extract_first()
# 把自己的item抛出给pipeline
yield myitem
总体思路是通过parse的自动调用获取href，然后使用Request请求获取新的网页内容进行进一步处理。
如果要爬取的网页有n层href，则调用Request n次，直到爬取到要获取数据的网页，否则保持Request和跳转访问（我的只有一层）href，即调整href一次）
其实内置函数parse的原理是类似的
scrapy分页抓取网页( WebScraper怎么对付这种类型的网页翻页?(图))
网站优化 • 优采云 发表了文章 • 0 个评论 • 60 次浏览 • 2022-02-03 08:19
scrapy分页抓取网页(
WebScraper怎么对付这种类型的网页翻页?(图))
这是简易数据分析系列文章的第12期。html
在之前的文章中文章我们介绍了Web Scraper处理各种页面翻转的解决方案，比如修改网页连接加载数据，点击“更多按钮”加载数据，下拉自动加载数据。今天我们讲一种比较常见的翻页方式——pager。网络
本来想解释一下什么是pager，但是看了一堆定义，觉得很麻烦。你不是第一年上网，看图就知道了。我找到了一个功能齐全的例子，支持数字页码调整，上一页到下一页和指定页数跳转。邮政
今天我们将学习 Web Scraper 如何处理这种类型的翻页。温泉
事实上，在本教程的第一个示例中，我们就抓取了豆瓣电影 TOP 榜单。这个豆瓣电影列表使用寻呼机来划分数据：代码
但是当时我们是在寻找网页连接规则来爬取，并没有使用pager来爬取。因为当一个网页的连接有规律的变化时，控制连接参数捕获是成本最低的；如果网页可以翻页，但是连接的变化不规律，就得去pager了一会儿。视频
说这些理论有点无聊，我们举个不规则翻页连接的例子。htm
8月2日是蔡徐坤的生日。为了庆祝，微博上的粉丝给了坤坤300W的转发。微博的转发数据恰好被寻呼机分割。我们来分析一下微博的转发。信息页面，了解如何使用 Web Scraper 抓取此类数据。博客
这条微博的直接链接是：教程
元素
看了这么多他的视频，为了表达我们的感激之情，我们可以点进点出给坤坤加个阅读。
首先我们看一下第1页转发的连接，长这样：
第二页是这样的，我注意到有一个额外的#_rnd36 参数：
第三页参数为#_rnd39
第 4 页参数是#_rnd76：
又看了几个链接，发现这个转发页面的url没有规则，只能通过pager翻页加载数据。让我们开始我们的实践教学课程。
1.创建站点地图
我们首先创建一个SiteMap，这个时候命名为cxk，初始连接是。
2.为容器创建一个选择器
由于我们要点击pager，所以我们选择外层容器的类型为Element Click。具体参数说明见下图。我们之前在《简单数据分析08》中详细讲解过，这里就不多说了。
容器的预览如下图所示：
寻呼机选择过程如下图所示：
3.创建子选择器
这些子选择器比较简单，类型都是文本选择器。我们选择了三种类型的内容：评论用户名、评论内容和评论时间。
4.捕获数据
可以根据Sitemap cxk -> Scrape 的操作路径抓取数据。
5.一些问题
如果你看了我上面的教程，马上爬数据，你可能遇到的第一个问题是，300w数据，我是不是都爬下来了？
听起来很不现实。毕竟Web Scraper针对的数据量比较少，上万的数据算太多了。不管数据有多大，都要考虑爬取时间是否过长，数据如何存储，如何处理。网站的反爬系统（比如突然弹出一个验证码，这个Web Scraper无能为力）。
考虑到这个问题，如果你看过上一篇关于自动控制抓取次数的教程，你可能会想到使用 :nth-of-type(-n+N) 来控制 N 条数据的抓取。如果你尝试一下，你会发现这个方法根本行不通。
失败的原因其实涉及到一点网页知识。如果您有兴趣，可以阅读下面的说明。不感兴趣的可以直接看最后的结论。
就像我之前介绍的更多加载页面和下拉加载页面一样，它们新加载的数据会附加到当前页面。表示所有数据都在同一页面上。
当我们使用：nth-of-type(-n+N)来控制加载次数的时候，其实就是在这个网页上设置一个计数器。当数据已经累积到我们想要的数量时，就会停止爬取。
但是，对于使用寻呼机的网页，每次翻页到刷新当前网页时，都会设置一个计数器。
比如你要抓1000条数据，但是第一页只有20条数据，抓到最后一条，还有980条数据；对于一条数据，还有980，一翻页计数器就清零，又变成1000了……所以这种控制数量的方法是无效的。
所以得出的结论是，寻呼机类型的网页如果想要提前结束爬取，唯一的办法就是断网。当然，如果你有更好的解决方案，可以在评论中回复我，我们可以互相讨论。
6.总结
分页器是一种非常常见的网页分页方法。我们可以通过 Web Scraper 中的 Element click 处理此类网页，并通过断开网络来结束爬取。 查看全部
WebScraper怎么对付这种类型的网页翻页?(图))
这是简易数据分析系列文章的第12期。html
在之前的文章中文章我们介绍了Web Scraper处理各种页面翻转的解决方案，比如修改网页连接加载数据，点击“更多按钮”加载数据，下拉自动加载数据。今天我们讲一种比较常见的翻页方式——pager。网络
本来想解释一下什么是pager，但是看了一堆定义，觉得很麻烦。你不是第一年上网，看图就知道了。我找到了一个功能齐全的例子，支持数字页码调整，上一页到下一页和指定页数跳转。邮政
今天我们将学习 Web Scraper 如何处理这种类型的翻页。温泉
事实上，在本教程的第一个示例中，我们就抓取了豆瓣电影 TOP 榜单。这个豆瓣电影列表使用寻呼机来划分数据：代码
但是当时我们是在寻找网页连接规则来爬取，并没有使用pager来爬取。因为当一个网页的连接有规律的变化时，控制连接参数捕获是成本最低的；如果网页可以翻页，但是连接的变化不规律，就得去pager了一会儿。视频
说这些理论有点无聊，我们举个不规则翻页连接的例子。htm
8月2日是蔡徐坤的生日。为了庆祝，微博上的粉丝给了坤坤300W的转发。微博的转发数据恰好被寻呼机分割。我们来分析一下微博的转发。信息页面，了解如何使用 Web Scraper 抓取此类数据。博客
这条微博的直接链接是：教程
元素
看了这么多他的视频，为了表达我们的感激之情，我们可以点进点出给坤坤加个阅读。
首先我们看一下第1页转发的连接，长这样：
第二页是这样的，我注意到有一个额外的#_rnd36 参数：
第三页参数为#_rnd39
第 4 页参数是#_rnd76：
又看了几个链接，发现这个转发页面的url没有规则，只能通过pager翻页加载数据。让我们开始我们的实践教学课程。
1.创建站点地图
我们首先创建一个SiteMap，这个时候命名为cxk，初始连接是。
2.为容器创建一个选择器
由于我们要点击pager，所以我们选择外层容器的类型为Element Click。具体参数说明见下图。我们之前在《简单数据分析08》中详细讲解过，这里就不多说了。
容器的预览如下图所示：
寻呼机选择过程如下图所示：
3.创建子选择器
这些子选择器比较简单，类型都是文本选择器。我们选择了三种类型的内容：评论用户名、评论内容和评论时间。
4.捕获数据
可以根据Sitemap cxk -> Scrape 的操作路径抓取数据。
5.一些问题
如果你看了我上面的教程，马上爬数据，你可能遇到的第一个问题是，300w数据，我是不是都爬下来了？
听起来很不现实。毕竟Web Scraper针对的数据量比较少，上万的数据算太多了。不管数据有多大，都要考虑爬取时间是否过长，数据如何存储，如何处理。网站的反爬系统（比如突然弹出一个验证码，这个Web Scraper无能为力）。
考虑到这个问题，如果你看过上一篇关于自动控制抓取次数的教程，你可能会想到使用 :nth-of-type(-n+N) 来控制 N 条数据的抓取。如果你尝试一下，你会发现这个方法根本行不通。
失败的原因其实涉及到一点网页知识。如果您有兴趣，可以阅读下面的说明。不感兴趣的可以直接看最后的结论。
就像我之前介绍的更多加载页面和下拉加载页面一样，它们新加载的数据会附加到当前页面。表示所有数据都在同一页面上。
当我们使用：nth-of-type(-n+N)来控制加载次数的时候，其实就是在这个网页上设置一个计数器。当数据已经累积到我们想要的数量时，就会停止爬取。
但是，对于使用寻呼机的网页，每次翻页到刷新当前网页时，都会设置一个计数器。
比如你要抓1000条数据，但是第一页只有20条数据，抓到最后一条，还有980条数据；对于一条数据，还有980，一翻页计数器就清零，又变成1000了……所以这种控制数量的方法是无效的。
所以得出的结论是，寻呼机类型的网页如果想要提前结束爬取，唯一的办法就是断网。当然，如果你有更好的解决方案，可以在评论中回复我，我们可以互相讨论。
6.总结
分页器是一种非常常见的网页分页方法。我们可以通过 Web Scraper 中的 Element click 处理此类网页，并通过断开网络来结束爬取。 查看全部
scrapy分页抓取网页(
WebScraper怎么对付这种类型的网页翻页?(图))
这是简易数据分析系列文章的第12期。html
在之前的文章中文章我们介绍了Web Scraper处理各种页面翻转的解决方案，比如修改网页连接加载数据，点击“更多按钮”加载数据，下拉自动加载数据。今天我们讲一种比较常见的翻页方式——pager。网络
本来想解释一下什么是pager，但是看了一堆定义，觉得很麻烦。你不是第一年上网，看图就知道了。我找到了一个功能齐全的例子，支持数字页码调整，上一页到下一页和指定页数跳转。邮政
今天我们将学习 Web Scraper 如何处理这种类型的翻页。温泉
事实上，在本教程的第一个示例中，我们就抓取了豆瓣电影 TOP 榜单。这个豆瓣电影列表使用寻呼机来划分数据：代码
但是当时我们是在寻找网页连接规则来爬取，并没有使用pager来爬取。因为当一个网页的连接有规律的变化时，控制连接参数捕获是成本最低的；如果网页可以翻页，但是连接的变化不规律，就得去pager了一会儿。视频
说这些理论有点无聊，我们举个不规则翻页连接的例子。htm
8月2日是蔡徐坤的生日。为了庆祝，微博上的粉丝给了坤坤300W的转发。微博的转发数据恰好被寻呼机分割。我们来分析一下微博的转发。信息页面，了解如何使用 Web Scraper 抓取此类数据。博客
这条微博的直接链接是：教程
元素
看了这么多他的视频，为了表达我们的感激之情，我们可以点进点出给坤坤加个阅读。
首先我们看一下第1页转发的连接，长这样：
第二页是这样的，我注意到有一个额外的#_rnd36 参数：
第三页参数为#_rnd39
第 4 页参数是#_rnd76：
又看了几个链接，发现这个转发页面的url没有规则，只能通过pager翻页加载数据。让我们开始我们的实践教学课程。
1.创建站点地图
我们首先创建一个SiteMap，这个时候命名为cxk，初始连接是。
2.为容器创建一个选择器
由于我们要点击pager，所以我们选择外层容器的类型为Element Click。具体参数说明见下图。我们之前在《简单数据分析08》中详细讲解过，这里就不多说了。
容器的预览如下图所示：
寻呼机选择过程如下图所示：
3.创建子选择器
这些子选择器比较简单，类型都是文本选择器。我们选择了三种类型的内容：评论用户名、评论内容和评论时间。
4.捕获数据
可以根据Sitemap cxk -> Scrape 的操作路径抓取数据。
5.一些问题
如果你看了我上面的教程，马上爬数据，你可能遇到的第一个问题是，300w数据，我是不是都爬下来了？
听起来很不现实。毕竟Web Scraper针对的数据量比较少，上万的数据算太多了。不管数据有多大，都要考虑爬取时间是否过长，数据如何存储，如何处理。网站的反爬系统（比如突然弹出一个验证码，这个Web Scraper无能为力）。
考虑到这个问题，如果你看过上一篇关于自动控制抓取次数的教程，你可能会想到使用 :nth-of-type(-n+N) 来控制 N 条数据的抓取。如果你尝试一下，你会发现这个方法根本行不通。
失败的原因其实涉及到一点网页知识。如果您有兴趣，可以阅读下面的说明。不感兴趣的可以直接看最后的结论。
就像我之前介绍的更多加载页面和下拉加载页面一样，它们新加载的数据会附加到当前页面。表示所有数据都在同一页面上。
当我们使用：nth-of-type(-n+N)来控制加载次数的时候，其实就是在这个网页上设置一个计数器。当数据已经累积到我们想要的数量时，就会停止爬取。
但是，对于使用寻呼机的网页，每次翻页到刷新当前网页时，都会设置一个计数器。
比如你要抓1000条数据，但是第一页只有20条数据，抓到最后一条，还有980条数据；对于一条数据，还有980，一翻页计数器就清零，又变成1000了……所以这种控制数量的方法是无效的。
所以得出的结论是，寻呼机类型的网页如果想要提前结束爬取，唯一的办法就是断网。当然，如果你有更好的解决方案，可以在评论中回复我，我们可以互相讨论。
6.总结
分页器是一种非常常见的网页分页方法。我们可以通过 Web Scraper 中的 Element click 处理此类网页，并通过断开网络来结束爬取。
