从0开始基于python3用scrapy爬取数据
写在开头：
博主刚开始爬取数据的时候选中的kanzhun网，结果被封了ip -_- 。查看了kanzhun网的robots协议(http://www.kanzhun.com/robots.txt)，发现它们非常严格，就是这个不让爬那个也不让爬。于是想起了参加儿博会的时候被安利的一个母婴电商app，一看他们连robots协议都没有，想必是程序员都去赶功能去了，应该是我们都喜闻乐见的网站。于是进去看了看...一共采集到了3000多个商品，发现大部分都是0-100元这个区间，还是挺亲民的价格，想了解
的可以联系我:)
摘要：
本文主要介绍0基础从python3的安装到使用scrapy框架抓取某母婴电商的数据并简单分析。主要包括以下内容：
第一爬：官网
第一次爬取数据强烈推荐内网系统，免得一个代理问题就让激情退却了：
安装python3
下载地址：https://www.python.org/downloads/
查看安装版本以验证安装成功：
$:python -V
注意：
1）python3和python2的差别非常大，大家在google的时候要看清楚是针对python2还是python3的。
比如在python2中，print是这样的
print "hello world"
而在python3中，print是函数要加上括号，变成了:
print("hello world")
2) python有很多多多多的库，可以通过pip install命令下载，例如下载我们前面画的那个柱状图的库：
pip install matplotlib
在python2.7和python3.6之后，pip已经集成到python安装包里面了，不用再单独下载。
3）如果是Mac用户，系统已经自带了python2.7，博主不敢随便升级，于是另外安装了python3。并不像网上很多老帖子写的需要装environment来切换两个python版本(猜测是针对windows用户的)。系统自带的python用python启动，而python3用命令python3启动，pip也是一样，有pip命令和pip3命令。就像是两个应用一样非常方便。
Zhuos-MacBook-Pro:demo jo$ python -V Python 2.7.13 Zhuos-MacBook-Pro:demo jo$ python3 -V Python 3.6.1
Windows用户如果要装两个版本...装好了来跟博主share下经验教训。
4）本文之后所有的代码示例都是基于python3的。
编辑器安装：
推荐使用pycharm，地址: https://www.jetbrains.com/pycharm/download/
爬取官网：
第一个爬虫代码，我们暂时不考虑url的相对路径问题，也不考虑公司代理问题等...下面的代码应该是最简单的了，再简单就是伪代码了。
import re
import urllib
import urllib.request
from collections import deque
url = "http://www.you_compay_home_page.com"
queue = deque()
visited = set()
total_count = 1
queue.append(url)
while queue:
url = queue.popleft()
visited |= {url}
print("正在抓取第 " + str(total_count) + " 个, " + url)
total_count += 1
urllop = urllib.request.urlopen(url, timeout=1)
if "html" not in urllop.getheader('Content-Type'):
print(urllop + " 不是html页面，忽略！")
continue
try:
data = urllop.read().decode("utf-8")
except Exception as e:
print(e)
continue
count_per_page = 0
linkre = re.compile('href="(.+?)"')
for x in linkre.findall(data):
if 'https://www.you_compay_home_page.com/' in x and x not in visited:
count_per_page += 1
queue.append(x) #注意调试的时候注释本行,以免对服务器造成压力
print("加入待爬页面：" + x)
print("本页面共加入待爬页面:" + str(count_per_page))
解释:
line1~4：
导入我们需要的依赖库：re是正则表达式，顾名思义urllib与urllib.request是针对url，deque是针对队列的.
line6~11：
url：爬虫的入口；queue：存放要爬取的页面；visited：存放已经爬取过的页面，防止重复爬取。
1）url，queue，visited，total_count都是对象引用。
2) python不用像java一样需要定义引用的类型，每个引用都知道自己指向的是什么类型的对象。
3) python中没有原子数据类型，都是对象，例如line17，total_count也是一个int型的对象。
line13：有没花括号了，取而代之的是冒号+缩进，例如if, while, try...
line18: urlopen这个方法只有一个url是必填参数，timeout是有默认值的参数，但是我们传入了自定义的值。
urllop = urllib.request.urlopen(url, timeout=1)
看看这个方法的定义：
def urlopen(url, data=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
*, cafile=None, capath=None, cadefault=False, context=None):
第一个url是必填参数，后面的data,timeout，cafile等是默认参数。我们调用该方法的时候，只提供了必选参数url和默认参数timeout。必选参数：url
默认参数：data, timeout
可变参数：无。 例如C中的数组指针*pointer，指向一个数组或元祖（元祖，既不可变的数组）。
命名关键字参数：cafile，capath，cadefault，context。 *,标志其后的参数是命名关键字参数，既只能指定参数名为cafile，capath，cadefault，context的参数。
关键字参数：无。**pointer，类似于C中传入一个二维指针，指向一个dict，包含了一组key-value对。
关于python的参数，Read More：http://blog.csdn.net/downing114/article/details/70257602?locationNum=2&fps=1
line29~35:通过正则表达式找到该页面包含的其他链接，加入到queue中等待被访问。
编写我们的pattern：href="(.+?)"，用这个pattern匹配读取到的网页数据data，匹配上的数据按照括号分组，linkre.findall(data)将返回分组数据，这里即为该页面中的其他链接。
第二爬：内网看板
看板系统需要登录，我们需要安装抓包的工具查看登录时发送给服务器的报文，让爬虫也能依样画葫芦的去登录。
抓包工具：Mac上我使用的是Charles试用版，Windwos上推荐Fiddler。
通过抓包工具我们可以看到发送到服务器的有4个field，用户名和密码都是自己录入的，另外两个字段应该是页面自己生成的，进一步查看页面，我们可以看到这两个字段在页面上的位置，通过正则表达式让爬虫看到token的值，以便后续和用户名，密码一起发送给服务器。
Tips: 对chrom和firefox,通过：
Windows：control+shift+i
Mac：command+option+i
打开开发者工具，切到Elements tab，就可以通过指到页面的元素，方便快捷的看到这个元素对应的html代码了。
Okay，我们想好了方法，就可以用手写伪装成浏览器获取token的代码了：
import re
import urllib
import urllib.request
import http.cookiejar
from collections import deque
print("\n\n*************** Step 1: visit index page and get the token generated in server side ******************")
url = "http://gitlab.your_company_addr.com/users/sign_in"
header = {
'Connection': 'Keep-Alive',
'Accept': 'text/html, application/xhtml+xml, */*',
'Accept-Language': 'en-US,en;q=0.8,zh-Hans-CN;q=0.5,zh-Hans;q=0.3',
'User-Agent': 'Mozilla/5.0 (Windows NT 6.3; WOW64; Trident/7.0; rv:11.0) like Gecko',
'Host': 'www.zhihu.com',
'DNT': '1'
# 'Cookie': '_gitlab_session=f00c50db7dc2c83989419079760e5786'
}
def getToken(data):
cer = re.compile('name=\"authenticity_token\" value=\"(.+?)\"')
strlist = cer.findall(data)
return strlist[0]
def getOpener(head):
# deal with the Cookies
cj = cj = http.cookiejar.CookieJar()
opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(cj))
header = []
for key, value in head.items():
elem = (key, value)
header.append(elem)
opener.addheaders = header
return opener
opener = getOpener(header)
op = opener.open(url)
data = op.read().decode("utf-8")
token = getToken(data)
print(token)
line9~17: 设置header的内容。我们这里构造的header在python中是一种dict数据结构。dict类似于java的map。存储key-value对。
line20~23: 编写获取页面token的方法，入参是网页内容，出参是通过正则表达式提取到的token。
line26~35: 编写方法获取包含了header的opener，之后我们都通过opener伪装成浏览器来打开网页。
line26~35: 调用方法获取opener，打开网页，读取到了数据后用utf-8编码，然后再调用getToken方法从编码后的数据中提取到token。
Tips: 使用什么字符集对获取到的网页数据编码呢？ 直接查看网页的head即可。Scrapy框架获取到页面不需要指定字符集，因为它对http报文解析得到了编码字符集。
<meta charset="utf-8">
print("\n\n*************** Step 2: login the server with username, password and token generated before **********")
url = "http://gitlab.your_company_addr.com/users/auth/ldapmain/callback"
postDict = {
'utf8': '✓',
'username': 'zhuoyp001',
'password': '********',
'authenticity_token': token
}
postData = urllib.parse.urlencode(postDict)
postData = postData.encode('utf-8')
res = opener.open(url, postData)
print(res.status, res.reason)
if (res.status != 200):
print("login failed")
exit()
print('login successfully!')
line3~line8:构造http post方法要post的数据。这也是一个dict数据结构，在提交给服务器前，需要进行url encode一下。print("\n\n*************** Step 3: begin scraping... **********")
baseUrl = "http://gitlab.your_company_addr.com/explore/projects"
project_queue = deque()
visited = set()
current_page = 1
page_amount = 3
url = baseUrl
while current_page <= page_amount:
url = baseUrl + "?page=" + str(current_page)
print("正在抓取第 " + str(current_page) + " 页, " + url)
try:
urllop = opener.open(url, timeout=1000)
data = urllop.read().decode("utf-8")
except:
print("error")
continue
linkre = re.compile('<a class="project" .*href="(/.+?)"') # match projects
for x in linkre.findall(data):
project_queue.append(x)
print("加入待爬页面：" + x)
current_page += 1
url = baseUrl + "?page=" + str(current_page)
line2: 第一个示例爬取主页中，我们从官网主页入手，找到了link就继续爬。而在本例中，我们已经知道了要爬的网站的结构，可以通过一个固定的baseUrl加上页码获得每个列表页面地址，再访问并解析每个列表页面，获得这个列表页面包含的project详细页面的地址，再将详细页面地址存在内存等待爬取。
line3~7:跟第一个示例一样，project_queue是要爬的页面，visited是已经访问过的页面，current_page是当前页面，page_amount是通过正则表达式获得的总页面页数。（这里省略了正则取总页数的代码，直接设置为line13: 获取到一个列表页面
line17：在这个列表页面，凡是class定义为class的a标签，都是指向一个project，我们将这个project的地址放入project_queue中等待爬取。
通过解析完所有的列表页面，就将所有的project的地址放入了project_queue了，接下来就是逐个访问project_queue中的页面，将我们需要的信息提取出来：
print("\n\n*************** Step 4: visit each project and aggregate data")
class Issue:
def __init__(self, project=None, open=0, closed=0):
self.project = project
self.open = open
self.closed = closed
projects_found = 0
project_list = []
while project_queue:
project = project_queue.popleft()
project_url = "http://gitlab.your_company_addr.com" + project + "/issues"
try:
project = str(project).rsplit(sep="/", maxsplit=1)[-1]
issue = Issue(project)
project_page = opener.open(project_url, timeout=1000)
data = project_page.read().decode("utf-8")
openre = re.compile('<span>Open</span>.*<span class="badge">(.+?)</span>')
for openNum in openre.findall(data):
projects_found += 1
issue.open = int(openNum)
#省略对其他字段的提取
project_list.append(issue)
except:
print("error page: " + project_url)
traceback.print_exc()
continue
line4~8:定义了一个Issue类，包括project的名字，以及project open的issue个数，closed的issue个数.
self:只要是类的成员方法，第一个参数都是self，调用这个方法的当前的对象，相当于java的this。
__init__：python中的构造方法。
line12：python中空的字符串、空集合、0，在取他们的bool量的时候，默认都是false。
line13~14：从project_queue中获取到一个项目地址的相对路径，构造这个project的issue地址。
line18~24：从project issue页面获取到数据，通过解析得到我们想要的数据，封装到issue对象中。
line26：将每个issue加入到list中。最终我们要分析和制图的入参即是这个list。
最后我们得到一共多少个项目，其中每个项目的open的issue有多少个，closed的issue有多少个。那么我们可以进行图表展示了。先上一个画出来的示例图看看：
print("\n\n*************** Step 5: analyze data and write pic")
project_names = []
project_open = []
project_closed = []
N = 0
for i in range(len(project_list)):
if project_list[i].all > 0:
project_names.append(project_list[i].project)
project_open.append(project_list[i].open)
project_closed.append(project_list[i].closed)
N += 1
names = tuple(project_names)
open = tuple(project_open)
closed = tuple(project_closed)
ind = np.arange(N) # the x locations for the groups
width = 0.65 # the width of the bars: can also be len(x) sequence
p1 = plt.bar(ind, open, width, color='#d62728')
p2 = plt.bar(ind, closed, width, bottom=open)
plt.ylabel('issues')
plt.title('project issues')
plt.xticks(ind, names)
plt.yticks(np.arange(0, 81, 10))
plt.legend((p1[0], p2[0]), ('open issues', 'closed issues'))
plt.show()
line20,21,25：这里都是调用pylab的函数，可以看到它画图需要的是三个list，因此在13~15行将我们的List<Issue>转为三个list。
对于pylab，不是我们爬虫讨论的重点，有兴趣自己google吧。
第三爬：Scrapy
安装scrapy
scrapy需要wheel来安装一些依赖，首先安装wheel：
pip install wheel
验证：
wheel
使用pip安装scrapy(博主没有成功，在windows下有问题。。大家可以试试，不行再按后面的操作安装)：
pip install Scrapy
Tip：如果是Mac用户，记得pip要用pip3哦~
如果上述有报错失败了，可以尝试使用wheel文件方式安装：
先卸载scrapy
pip uninstall Scrapy
下载scrapy和它依赖的wheel文件：twisted， lxml，scrapy
下载地址：http://www.lfd.uci.edu/~gohlke/pythonlibs/
找到Twisted， lxml和Scrapy的whl文件.
Twisted‑17.1.0‑cp36‑cp36m‑win32.whl
lxml‑3.7.3‑cp36‑cp36m‑win32.whl
Scrapy‑1.4.0‑py2.py3‑none‑any.whl
注意：cp36指的是python的版本，而win32不是我们windows的版本，如果win64不成功可以试试win32.
下载并安装，例如:
pip install xxx.whl
验证scrapy安装成功：
scrapy
reference: http://scrapy-chs.readthedocs.io/zh_CN/0.24/intro/tutorial.html
创建scrapy项目
scrapy startproject demo
在spiders目录下新建一个spider类，取名为demo,
import scrapy
import logging
header = {
'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11',
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.3',
# 'Accept-Encoding': LxxxSpider.py'gzip, deflate',
'Accept-Language': 'en-US,en;q=0.8',
'Host': 'www.lxxx.com.cn',
'Connection': 'keep-alive'}
# scrapy crawl demo
class Demopider(scrapy.Spider):
name = "demo"
def start_requests(self):
urls = [
'http://www.lxxx.com.cn/',
]
for url in urls:
yield scrapy.Request(url=url, callback=self.parse_home, headers=header)
def parse_home(self, response):
content = response.body.decode("gb2312", "ignore")
logging.debug("Open home page \n\n" + content)
line4~11：设置我们的header伪装浏览器，应该不陌生了：）
line16：定义我们的DemoSpider类，它继承了scrapy.Spider类。
line17：给我们的spider类取名字，后面我们将用这个名字启动爬虫。
line19~24：start_requests这个方法类定义入爬虫的入口页面，以及访问了这个页面后回调的函数。
line24：python的yeild一般用于一个for循环中，作为一个generator，这里代码解析的时候并不会真的产生一个request，而是在for循环内执行到这一句的时候，才计算如何产生request。这里代表产生一个url的访问，数据取回来后用self.parse_home来解析取回页面。
详细可以百度之.这里简单refer一个：https://www.ibm.com/developerworks/cn/opensource/os-cn-python-yield/
line24~28：编写在24行调用的回调函数。
Scrappy Proxy设置
1）在demo/middlewares.py文件下新建ProxyMiddleware类
class ProxyMiddleware(object):
# overwrite process request
def process_request(self, request, spider):
# Set the location of the proxy
request.meta['proxy'] = "http://host:port"
2）在demo/settings.py文件末增加对ProxyMiddleware的配置：
DOWNLOADER_MIDDLEWARES = {
'scrapy.contrib.downloadermiddleware.httpproxy.HttpProxyMiddleware': 110,
'demo.middlewares.ProxyMiddleware': 100,
}
middleware是一个dict，key是middleware class path，value是 the middleware orders。Order越小越靠近engine，越大越靠近downloader。这是什么意思呢？请看下图：
此图是scrapy的架构图，spider可以看成我们写的代码，如何用正则解析确认哪些页面需要。我们定义好了后调用yield scrapy.Request就将这个请求送到了引擎中（图中步骤1）。引擎通过scheduler（步骤23）, dowloader（步骤45）等获取到了response后，将页面再返回给spider，spider执行我们代码中的 scrapy.Request中的回调函数（步骤6），解析返回的reponse后在发起request（步骤7），在步骤4<-->5，6<-->7中，紫色的hook就是middlewares，这些middleware按顺序排列。
对于DOWNLOADER_MIDDLEWARES，数字越小的越靠近引擎，即越先执行process_request方法，数字越大的越靠近downloader，即越先执行process_response方法。
例如，如果优先执行的process_request返回了response，后面middleware的process_request或者process_exeception就不会被执行了；如果返回的none，则后面的process_request会继续执行直到有response返回；如果返回的是一个request（是的，你没看错），则这个response不会继续执行了，而是reschedule request。
class DownloaderMiddlewareManager(MiddlewareManager):
def __init__(self, *middlewares):
self.middlewares = middlewares
self.methods = defaultdict(list)
for mw in middlewares:
self._add_middleware(mw)
def _add_middleware(self, mw):
if hasattr(mw, 'process_request'):
self.methods['process_request'].append(mw.process_request)
if hasattr(mw, 'process_response'):
self.methods['process_response'].insert(0, mw.process_response)
if hasattr(mw, 'process_exception'):
self.methods['process_exception'].insert(0, mw.process_exception)
这是scrapy的源码，对于每个middleware，如果它有process_reques方法，就把它加入到process_request middleware list里面；反之如果有process_response方法，就按加入到process_response middleware list中。
所以，在我们的例子中，在发起request时，是先执行order 顺序小的，即先设置我们自己定义的proxy。
refer to：https://*.com/questions/6623470/scrapy-middleware-order
在下面的渲染ps部分，我们将实现自己的downloader，编码process_response方法，由于要等待页面渲染完成再下载，因此我们这个downloader的order将被设置成999。
还是不知道该设置成多少order对吧？这里有内置的middleware的order，可以和内置的比大小来设置自己的order。refer to：https://docs.scrapy.org/en/latest/topics/settings.html#std:setting-DOWNLOADER_MIDDLEWARES_BASE
{
'scrapy.downloadermiddlewares.robotstxt.RobotsTxtMiddleware': 100,
'scrapy.downloadermiddlewares.httpauth.HttpAuthMiddleware': 300,
'scrapy.downloadermiddlewares.downloadtimeout.DownloadTimeoutMiddleware': 350,
'scrapy.downloadermiddlewares.defaultheaders.DefaultHeadersMiddleware': 400,
'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': 500,
'scrapy.downloadermiddlewares.retry.RetryMiddleware': 550,
'scrapy.downloadermiddlewares.ajaxcrawl.AjaxCrawlMiddleware': 560,
'scrapy.downloadermiddlewares.redirect.MetaRefreshMiddleware': 580,
'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 590,
'scrapy.downloadermiddlewares.redirect.RedirectMiddleware': 600,
'scrapy.downloadermiddlewares.cookies.CookiesMiddleware': 700,
'scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware': 750,
'scrapy.downloadermiddlewares.stats.DownloaderStats': 850,
'scrapy.downloadermiddlewares.httpcache.HttpCacheMiddleware': 900,
}
启动demo爬虫
scrapy crawl demo
在settings的同级目录下新建一个py文件，比如命名为run.py，用这个命令来执行我们上面的启动命令：
# -*- coding: utf-8 -*-
from scrapy import cmdline
name = 'demo'
cmd = 'scrapy crawl {0}'.format(name)
cmdline.execute(cmd.split())
然后就可以打断点了，打完断点，在run.py文件上右键点“debug”，启动程序。就可以debug了
解析并下载网页
def start_requests(self):
urls = [
'http://www.lxxx.com.cn/',
]
for url in urls:
yield scrapy.Request(url=url, callback=self.parse_home, headers=header)
def parse_home(self, response):
content = response.body.decode("gb2312", "ignore")
linkre = re.compile(
'<a .*href="((/|http://www.lxxx.com.cn/|http://s.lxxx.com.cn/|http://item.lxxx.com.cn/)product/.+?)"')
for link in linkre.findall(content):
url = str(link[0])
full_url = response.urljoin(url)
try:
logging.debug("|--Will opne pages with its full url : " + full_url)
yield scrapy.Request(full_url, callback=self.parse_page)
except Exception as e:
logging.debug("\n\nError: " + e)
continue
def parse_page(self, response):
url = response.url
product_detail = response.xpath('//div[@ng-app="singleApp"]')
total_page = response.xpath('//li[@id="fenyes"]/span/text()')
logging.debug("|-Opened one page : " + url)
if product_detail != []:
logging.debug("|--Found one detail page: " + url)
DemoSpider.download_detail(response)
elif product_detail == [] and total_page != []:
logging.debug("|--Found one list page: " + url)
brand_lst = response.xpath('//span[@class="damon_brand"]/text()').extract()
DemoSpider.add_brands(brand_lst)
logging.debug("|-In a list page : " + url)
total_page = response.xpath('//li[@id="fenyes"]/span/text()').extract_first()
total_page = total_page[total_page.index('共') + 1:total_page.index('页')]
logging.debug("|-Analyze pagesize : " + url + " pagesize: " + total_page)
query_str = DemoSpider.analyze_quer_str(url)
for page in range(1, int(total_page)):
next_list_page = "http://www.lxxx.com.cn/newweb/ajaxfile/skuslie.php?random=0.6151283582927061" + query_str + "&page=" + str(
page)
logging.debug("|--Will go the next page : " + next_list_page + " page: " + str(page))
yield scrapy.Request(url=next_list_page, callback=self.parse_list, headers=header)
else:
logging.debug("|--Found one unknown page : " + url)
line2~6：设置要爬的网站的入口地址，这里只有一个，lxxx的主页。取回来的入口页面都用self.parse_home解析。
line10：解析主页的函数，定义主页中包含的我们要继续爬取的url的正则表达式。
line12~20：遍历匹配的url地址，通过urljoin方法将路径都转换成绝对路径，然后继续产生访问这些url的request，并用parse_page函数来解析这些url。
line22~47：parse_page函数，解析当前页面，当前页面有三种可能：
第一种是产品详细页面(line28~29)，包括商品定价，描述等。这种页面是我们需要的目标页面，直接下载line29；
第二种是商品的列表页面(line30~45)，包含了分页，每一页都连接了很多商品详细页面。这类需要进一步解析总共的页面并进一步访问每页，对每个分页页面，执行parse_list (line45)进一步解析出其每页的产品。
第三种是其他页面，比如报错页面等，暂时直接忽略掉。
JS渲染
大部分页面下载后都能正常显示，但是发现有几个页面如下，是使用的angularjs进行渲染页面的，我们下载页面的时候，页面的渲染还没有完成，因此我们需要的数据都还是angularjs的代码。通过selenium操作chromedriver来等待页面渲染完成后，我们在读取response的数据。如下图一是用了selenium渲染后与渲染前的对比：
为了等待js渲染完成再下载页面，我们需要编写downloader中间件，采用selenium来渲染js。
scrapy的中间件知识refer to：http://scrapy-chs.readthedocs.io/zh_CN/1.0/topics/downloader-middleware.html
创建一个渲染js的middleware：
class JavaScriptMiddleware(object):
def process_request(self, request, spider):
print("Chrome is starting...")
driver = webdriver.Chrome() # PhantomJS与angularjs有点问题，我们用chrome
driver.get(request.url)
time.sleep(3)
body = driver.page_source
print("访问" + request.url)
return HtmlResponse(driver.current_url, body=body, encoding='utf8', request=request)
line4：需要用到chromedriver，通过以下命令安装：brew install chromedriver --verboseline6：这里我们等了3秒等待页面加载完成，这会大大的延迟爬取时间。优化方案可以是加个循环条件判断期望的一个值是否已经出现了，来判断是否加载完成。
在settings里面设置该JavaScriptMiddleware proxy：
DOWNLOADER_MIDDLEWARES = {
'scrapy.contrib.downloadermiddleware.httpproxy.HttpProxyMiddleware': 110,
'demo.middlewares.ProxyMiddleware': 100,
'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
'demo.middlewares.JavaScriptMiddleware': 543
}
line4：对于scrapy内置的middlewares，默认都是启动的，如果不想用，要手动的设置他们的order为None。
上一篇： python之scrapy(一)