Scrapy框架2
一、进程、线程、协成
1、进程、线程、协成之间的关系
1、 线程是计算机中最小的工作单元。
2、 进程是提供资源供n个线程使用，即进程是最小的管理单元。
3、协程是人为控制的线程。
4、总结：1、python中由于有 GIL锁的存在，所以一个进程中同一时刻只有一个线程被CPU调度，所以在计算密集型，使用多进程而在io密集型使用多线程。
2、使用协成可以实现单线程下的并发，线程中cpu在遇到io操作时就会切到下一个线程中，这样大大的影响的效率于是人为的控制cpu在线程中的切换，当cpu在线程中遇到io会切换到该线程的下一个程序中这就是协成
2、异步非阻塞模块
1、gevent模块，基于协程的异步非阻塞模块。
2、Twisted，基于事件驱动（while循环检测）异步非阻塞模块（框架）。
3、非阻塞是指不等待 ，异步是指回调，执行某个任务完成之后，自动执行的函数。回调函数
二、scarpy框架
1、重写scrapy请求头方法
# -*- coding: utf-8 -*- import scrapy from scrapy.http import Request from scrapy.selector import HtmlXPathSelector #response= HtmlXPathSelector(response)主要是在parse函数中使用，
from urllib.parse import urlencode
from ..items import MyscrapyItem class BaiduSpider(scrapy.Spider): name = 'baidu' #爬虫应用的名称，通过此名称启动爬虫命令 allowed_domains = ['www.amazon.cn'] # 允许爬取数据的域名 def __init__(self,keywords=None,*args,**kwargs): super(BaiduSpider,self).__init__(*args,**kwargs) self.keywords=keywords #主要是接受一些外部传进来的参数 def start_requests(self): #重写scrapy请求头url必须写这个名字的函数 url='https://www.amazon.cn/s/ref=nb_sb_noss_1?' #新url parmas={ 'field-keywords':self.keywords #主要是定义一些外部传进来的参数 } url=url+urlencode(parmas,encoding='utf-8') #路径拼接，形成一个完整的url路径 yield Request(url,callback=self.parse_index) #yield返回数据给回调函数，也可以是return+[]的方式返回数据给回调函数，yield返回的是生成器，return+[]返回的可迭代对象 # return [Request(url='www.baidu.com',callback=self.parse),] def parse_index(self, response): urls=response.xpath('//*[contains(@id,"result_"]/div/div[3]/div[1]/a/@href').extract() for url in urls: print(url) yield Request(url,callback=self.parse) #返回详情页的信息 next_url=response.urljoin(response.xpath('//*[@id="pagnNextLink"]/@href').extract_first()) yield Request(next_url,callback=self.parse_index) #返回下一页的url路径，返回的是个Request对象 def parse(self, response): price=response.xpath('//*[@id="priceblock_ourprice"]/text()').extract_first().strip() colour=response.xpath('//*[@id="variation_color_name"]/div/span/text()').extract_first().strip() item=MyscrapyItem() item['price']=price item['colour']=colour return item #返回的是个item对象
或者是这种格式，只要返回的是个item对象及格
obj = XiaoHuarItem(price=price, colour=colour, )
yield obj
2、items文件写法
import scrapy
class MyscrapyItem(scrapy.Item):
price=scrapy.Field()
colour=scrapy.Field()
3、自定义pipelines文件
from scrapy.exceptions import DropItem #主动触发异常用的
class CustomPipeline(object):
def __init__(self,val):
self.vale = val #构造一个对象特有的方法
def process_item(self, item, spider): #用于存储爬取的数据，可以存储在文件也可以存储在数据库。
f=opne('item.log','a+')
f.write(item.price,item.colour)
f.close()
return item # return表示会被后续的pipeline继续处理，因为有可以一个爬虫项目会有多个爬虫程序一起执行，但是都有写入同一个文件中，那就让第一个文件写入，其余后面的文件不用重复写入。
# raise DropItem() # 表示将item丢弃，不会被后续pipeline处理
# if spider.name='baidu': #这就表示该文件只是存储这个名字的爬虫爬取的数据
#f=opne('item.log','a+')
#f.write(item.price,item.colour)
#f.close()
#return item
@classmethod
def from_crawler(cls, crawler):#初始化时候，用于创建pipeline对象，crawler这个类可以得到settings配置文件内的数据,如果需要给pipeline对象创建某个额外的参数就可以用这中方法
val = crawler.settings.getint('MMMM') #val = crawler.settings.get('MMMM') 读取配置文件的某个信息
return cls(val)
def open_spider(self,spider): #在爬虫程序开始执行之前调用该方法
print('000000')
def close_spider(self,spider): #在爬虫程序关闭后调用该方法
print('111111')
总结：这五个方法的执行顺序： 先执行from_crawler方法，用于初始化数据的时候读取配置文件，然后再执行爬虫程序的__init__方法，然后程序启动前执行open_spider方法，程序结束前保存数据时执行process_item方法，程序结果后
执行close_spider方法。
4、自定义url去重功能
scrapy默认使用 scrapy.dupefilter.RFPDupeFilter 进行去重，settings相关配置有：
DUPEFILTER_CLASS = 'scrapy.dupefilter.RFPDupeFilter' #去重文件，可以自定义 DUPEFILTER_DEBUG = False #默认去重功能是关闭的可以在settings中打开去重功能也可以在爬虫程序中手动指定去重 yield Request(url,callback=self.parse,dont_filter=True) JOBDIR = "保存范文记录的日志路径，如：/root/" # 最终路径为 /root/requests.seen 默认url是存放在内存中的，只要添加上jobdir就可以吧url存放在指定文件中
自己写一个去重规则
class RepeatUrl:
def __init__(self):
self.visited_url = set() #默认是一个集合，也可以是自定义链接一个数据库，文件等
@classmethod
def from_settings(cls, settings):
"""
初始化时，调用
"""
return cls()
def request_seen(self, request):
"""
检测当前请求是否已经被访问过
:param request:
:return: True表示已经访问过；False表示未访问过
"""
if request.url in self.visited_url:
return True
self.visited_url.add(request.url)
return False
def open(self):
"""
开始爬去请求时，调用
:return:
"""
print('open replication')
def close(self, reason):
"""
结束爬虫爬取时，调用
:param reason:
:return:
"""
print('close replication')
def log(self, request, spider):
"""
记录日志
:param request:
:param spider:
:return:
"""
print('repeat', request.url)
注意：写好自定义的去重规则后要将该文件设置到settings中该规程才能生效 比如：DUPEFILTER_CLASS = 'scrapy.dupefilter.RFPDupeFilter'
5、自定义命令
#自定制一键启动所有爬虫命令
from scrapy.commands import ScrapyCommand from scrapy.utils.project import get_project_settings class Command(ScrapyCommand): requires_project = True def syntax(self): return '[options]' def short_desc(self): return 'Runs all of the spiders' def run(self, args, opts): #这是源码的入口 spider_list = self.crawler_process.spiders.list() for name in spider_list: #循环所有的爬虫程序名称 self.crawler_process.crawl(name, **opts.__dict__) #准备所有的爬虫程序 self.crawler_process.start() #开始爬取任务
注意：1、在spiders同级创建任意目录，如：commands
2、在其中创建 crawlall.py 文件 （此处文件名就是自定义的命令）
3、在settings.py 中添加配置 COMMANDS_MODULE = '项目名称.目录名称'
4、在项目目录执行命令：scrapy crawlall
#自定制在py文件中启动某个爬虫命令
from scrapy.cmdline import execute
execute(['scrapy', '命令', '爬虫程序名称','-a','传入的参数'])
eg:execute(['scrapy', 'crawl', 'baidu','-a','keywords=iphone7'])
注意：自定制的py文件名称必须是entrypoint.py
6、自定义信号
from scrapy import signals
class MyExtension(object):
def __init__(self, value):
self.value = value #定义自己想要的方法
@classmethod
def from_crawler(cls, crawler): #扩展功能，在扩展功能里注册信号
val = crawler.settings.getint('MMMM')#读取配置文件信息
ext = cls(val)
crawler.signals.connect(ext.spider_opened, signal=signals.spider_opened) #注册信号
crawler.signals.connect(ext.spider_closed, signal=signals.spider_closed) #注册信号，可以注册很多信号，看源码
return ext #如果不需要扩展功能那么就直接注册信号即可
def spider_opened(self, spider): #爬虫程序启动时触发的信号
print('open')
def spider_closed(self, spider): #爬虫程序关闭时触发的信号
print('close')
注释：1、在项目目录下创建一个py文件，将自定义的信号写入该文件，建议py文件名为extensions
2、在settings中注册自定义信号的文件
eg:EXTENSIONS = {'scrapy.extensions.telnet.TelnetConsole': 300,}
7、中间件
#下载中间件
class DownMiddleware1(object): def process_request(self, request, spider): #请求过去的中间件带的时request """ 请求需要被下载时，经过所有下载器中间件的process_request调用 return: None,继续后续中间件去下载，默认就是什么都不返回； Response对象，停止process_request的执行，开始执行process_response，先导入Response(from scrapy.http import Response)
eg：return Response(url='http://www.baidu.com',request=request) #只要返回Response对象就不会执行后续的Request，而是直接执行Response Request对象，停止中间件的执行，将Request重新调度器 #如果返回的是Request对象那就不会执行后续的Request和Reques而是直接到引擎，重新调度 raise IgnoreRequest异常，停止process_request的执行，开始执行process_exception """ pass def process_response(self, request, response, spider): #返回数据的中间件带的时response """ spider处理完成，返回时调用，默认返回的就是Response return: Response 对象：转交给其他中间件process_response Request 对象：停止中间件，request会被重新调度下载 raise IgnoreRequest 异常：调用Request.errback """ return response def process_exception(self, request, exception, spider): """ 当下载处理器(download handler)或 process_request() (下载中间件)抛出异常的时候调用 :return: None：继续交给后续中间件处理异常； Response对象：停止后续process_exception方法，正确执行后续方法 Request对象：停止中间件后续方法，request将会被重新调用下载 """ return None
注释：1、在项目目录下创建.py文件，将中间件代码写在该文件中，建议文件名称为DownMiddleware
2、在settings中注册中间件，DOWNLOADER_MIDDLEWARES = {'chouti.middlewares.MyCustomDownloaderMiddleware': 600,}，写了几个中间件就注册几个中间件
3、可以在中间件的process_request中将所有的Request请求添加上请求头，添加cookies等操作，也可以添加代理，判断那个Request需要代理。
#爬虫中间件
class SpiderMiddleware(object):
def process_spider_input(self,response, spider):
"""下载完成，执行，然后交给parse处理，默认返回none"""
pass
def process_spider_output(self,response, result, spider):
"""spider处理完成，返回时调用，return: 必须返回包含 Request 或 Item 对象的可迭代对象(iterable)"""
return result
def process_spider_exception(self,response, exception, spider):
"""异常调用，return: None,继续交给后续中间件处理异常；含 Response 或 Item 的可迭代对象(iterable)，交给调度器或pipeline"""
return None
def process_start_requests(self,start_requests, spider):
"""爬虫启动时调用，return: 包含 Request 对象的可迭代对象，由于爬虫只是启动一次所以process_start_requests也只是调用一次 """
return start_requests
注释：1、在项目目录下创建.py文件，将中间件代码写在该文件中，建议文件名称为SpiderMiddleware
2、在settings中注册中间件，SPIDER_MIDDLEWARES = { 'chouti.middlewares.ChoutiSpiderMiddleware': 600,}，写了几个中间件就注册几个中间件
8、自定义代理
代理，需要在环境变量中设置
from scrapy.contrib.downloadermiddleware.httpproxy import HttpProxyMiddleware
方式一：使用默认
import os
os.environ
{
http_proxy:http://root:woshiniba@192.168.11.11:9999/ #有的代理链接是需要用户名和密码的，这个就是root为用户名，woshiniba为密码
https_proxy:http://192.168.11.11:9999/
} #该方法只需要在爬虫程序文件的类的__init__中添加上就可以了，程序会判断只要是_prxoy结尾的就会吧这个代理拿出来
方式二：使用自定义下载中间件
def to_bytes(text, encoding=None, errors='strict'):
if isinstance(text, bytes):
return text
if not isinstance(text, six.string_types):
raise TypeError('to_bytes must receive a unicode, str or bytes '
'object, got %s' % type(text).__name__)
if encoding is None:
encoding = 'utf-8'
return text.encode(encoding, errors)
class ProxyMiddleware(object):#代理中间件
def process_request(self, request, spider):
PROXIES = [
{'ip_port': '111.11.228.75:80', 'user_pass': ''},
{'ip_port': '120.198.243.22:80', 'user_pass': ''},
{'ip_port': '111.8.60.9:8123', 'user_pass': ''},
{'ip_port': '101.71.27.120:80', 'user_pass': ''},
{'ip_port': '122.96.59.104:80', 'user_pass': ''},
{'ip_port': '122.224.249.122:8088', 'user_pass': ''},
]
proxy = random.choice(PROXIES)#随机选择一个代理，高明就高明在这个地方，默认代理是不能随机生成的，所有也会有被封的风险。
if proxy['user_pass'] is not None:
request.meta['proxy'] = to_bytes（"http://%s" % proxy['ip_port']）#添加上代理
encoded_user_pass = base64.encodestring(to_bytes(proxy['user_pass']))#代理加密，固定加密方法
request.headers['Proxy-Authorization'] = to_bytes('Basic ' + encoded_user_pass) #代理授权
#print "**************ProxyMiddleware have pass************" + proxy['ip_port']
else:
#print "**************ProxyMiddleware no pass************" + proxy['ip_port']
request.meta['proxy'] = to_bytes("http://%s" % proxy['ip_port'])#添加代理
注释：1、在爬虫项目路径中创建代理文件
2、在settings中注册上代理 DOWNLOADER_MIDDLEWARES = { 'step8_king.middlewares.ProxyMiddleware': 500,}
9、settings配置文件详解
1. 爬虫名称 BOT_NAME = 'step8_king' 2. 爬虫应用路径 SPIDER_MODULES = ['step8_king.spiders'] #其实就是创建的爬虫程序名称+spiders NEWSPIDER_MODULE = 'step8_king.spiders'
3. 客户端 user-agent请求头 # USER_AGENT = 'step8_king (+http://www.yourdomain.com)' 4. 禁止爬虫配置（机器人协议） # ROBOTSTXT_OBEY = True
5. 并发请求数 # CONCURRENT_REQUESTS = 4 #一个线程最大能并发多少个请求，力度粗 6. 延迟下载秒数 # DOWNLOAD_DELAY = 2 默认是秒，每多少秒一次下载 7. 单域名访问并发数，并且延迟下次秒数也应用在每个域名 力度细 # CONCURRENT_REQUESTS_PER_DOMAIN = 2 # 单IP访问并发数，如果有值则忽略：CONCURRENT_REQUESTS_PER_DOMAIN，并且延迟下次秒数也应用在每个IP 力度细 # CONCURRENT_REQUESTS_PER_IP = 3 8. 是否支持cookie，cookiejar进行操作cookie # COOKIES_ENABLED = True # COOKIES_DEBUG = True
9. Telnet用于查看当前爬虫的信息，操作爬虫等... # 使用telnet ip port ，然后通过命令操作 # TELNETCONSOLE_ENABLED = True # TELNETCONSOLE_HOST = '127.0.0.1' # TELNETCONSOLE_PORT = [6023,] 10. 默认请求头，死板 # Override the default request headers: # DEFAULT_REQUEST_HEADERS = { # 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', # 'Accept-Language': 'en', # } 11. 定义pipeline处理请求 # ITEM_PIPELINES = { # 'step8_king.pipelines.JsonPipeline': 700, # 'step8_king.pipelines.FilePipeline': 500, # } 12. 自定义扩展，基于信号进行调用 # Enable or disable extensions # See http://scrapy.readthedocs.org/en/latest/topics/extensions.html # EXTENSIONS = { # # 'step8_king.extensions.MyExtension': 500, # } 13. 爬虫允许的最大深度，可以通过meta查看当前深度；0表示无深度 # DEPTH_LIMIT = 3 14. 爬取时，0表示深度优先Lifo(默认)；1表示广度优先FiFo # 后进先出，深度优先 # DEPTH_PRIORITY = 0 # SCHEDULER_DISK_QUEUE = 'scrapy.squeue.PickleLifoDiskQueue' # SCHEDULER_MEMORY_QUEUE = 'scrapy.squeue.LifoMemoryQueue'
# 先进先出，广度优先 # DEPTH_PRIORITY = 1 # SCHEDULER_DISK_QUEUE = 'scrapy.squeue.PickleFifoDiskQueue' # SCHEDULER_MEMORY_QUEUE = 'scrapy.squeue.FifoMemoryQueue' 15. 调度器队列 # SCHEDULER = 'scrapy.core.scheduler.Scheduler' # from scrapy.core.scheduler import Scheduler 16. 访问URL去重 # DUPEFILTER_CLASS = 'step8_king.duplication.RepeatUrl' """ 17. 自动限速算法 from scrapy.contrib.throttle import AutoThrottle 自动限速设置 1. 获取最小延迟 DOWNLOAD_DELAY 2. 获取最大延迟 AUTOTHROTTLE_MAX_DELAY 3. 设置初始下载延迟 AUTOTHROTTLE_START_DELAY 4. 当请求下载完成后，获取其"连接"时间 latency，即：请求连接到接受到响应头之间的时间 5. 用于计算的... AUTOTHROTTLE_TARGET_CONCURRENCY target_delay = latency / self.target_concurrency new_delay = (slot.delay + target_delay) / 2.0 # 表示上一次的延迟时间 new_delay = max(target_delay, new_delay) new_delay = min(max(self.mindelay, new_delay), self.maxdelay) slot.delay = new_delay """
10、https证书设置
Https访问时有两种情况：
1. 要爬取网站使用的可信任证书(默认支持)
DOWNLOADER_HTTPCLIENTFACTORY = "scrapy.core.downloader.webclient.ScrapyHTTPClientFactory"
DOWNLOADER_CLIENTCONTEXTFACTORY = "scrapy.core.downloader.contextfactory.ScrapyClientContextFactory"
2. 要爬取网站使用的自定义证书
DOWNLOADER_HTTPCLIENTFACTORY = "scrapy.core.downloader.webclient.ScrapyHTTPClientFactory"
DOWNLOADER_CLIENTCONTEXTFACTORY = "step8_king.https.MySSLFactory"
# https.py
from scrapy.core.downloader.contextfactory import ScrapyClientContextFactory
from twisted.internet.ssl import (optionsForClientTLS, CertificateOptions, PrivateCertificate)
class MySSLFactory(ScrapyClientContextFactory):
def getCertificateOptions(self):
from OpenSSL import crypto
v1 = crypto.load_privatekey(crypto.FILETYPE_PEM, open('/Users/wupeiqi/client.key.unsecure', mode='r').read()) #打开本地保存的证书文件
v2 = crypto.load_certificate(crypto.FILETYPE_PEM, open('/Users/wupeiqi/client.pem', mode='r').read())
return CertificateOptions(
privateKey=v1, # pKey对象
certificate=v2, # X509对象
verify=False,
method=getattr(self, 'method', getattr(self, '_ssl_method', None))
)
其他：
相关类
scrapy.core.downloader.handlers.http.HttpDownloadHandler
scrapy.core.downloader.webclient.ScrapyHTTPClientFactory
scrapy.core.downloader.contextfactory.ScrapyClientContextFactory
相关配置
DOWNLOADER_HTTPCLIENTFACTORY
DOWNLOADER_CLIENTCONTEXTFACTORY
