Requests爬虫和scrapy框架多线程爬虫

Posted blue-day

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Requests爬虫和scrapy框架多线程爬虫相关的知识,希望对你有一定的参考价值。

1.基于Requests和BeautifulSoup的单线程爬虫

1.1 BeautifulSoup用法总结

1. find,获取匹配的第一个标签

tag = soup.find(a)
print(tag)
tag = soup.find(name=a, attrs={class: sister}, recursive=True, text=Lacie)
tag = soup.find(name=a, class_=sister, recursive=True, text=Lacie)
print(tag)

2.find_all,获取匹配的所有标签,包含标签里的标签,若不想要标签里的标签,可将recursive(递归寻找)=False

tag = soup.find(a)
print(tag)
tag = soup.find(name=a, attrs={class: sister}, recursive=True, text=Lacie)
tag = soup.find(name=a, class_=sister, recursive=True, text=Lacie)
print(tag)

3.get 获得属性的值

img_url = soup.find(div,class_=main-image).find(img).get(src)

4.text 获取标签内容

title = soup.find(h2,class_=main-title).text.strip()

1.2 简单应用,爬取mzitu图片

import requests,os
from bs4 import BeautifulSoup


base_url = http://www.mzitu.com/
BASE_DIR = os.path.dirname(os.path.abspath(__file__))

r1 = requests.get(url=base_url)
# print(r1.text)
soup = BeautifulSoup(r1.text,features=lxml)
# 获取所有套图链接
tags = soup.find(name=ul,id="pins").find_all(li)
url_list = []
for tag in tags:
    url = tag.find(span).find(a).get(href)
    # print(img_url)
    url_list.append(url)

for url in url_list:
    # 获取套图链接信息
    r2 = requests.get(url=url)
    soup = BeautifulSoup(r2.text,features=lxml)

    title = soup.find(h2,class_=main-title).text.strip()
    # img_url = soup.find(‘div‘,class_=‘main-image‘).find(‘img‘).get(‘src‘)
    # 获取套图总张数
    num = int(soup.find(div,class_=pagenavi).find_all(span)[-2].text)
    # 保存路径文件夹
    path = os.path.join(BASE_DIR,title)
    # print(path)
    if os.path.exists(path):
        pass
    else:
        os.makedirs(path)
    #循环获取各图片URL
    for i in range(1,num+1):
        url_new = "%s/%s"%(url,i)
        r3 = requests.get(url=url_new)
        soup = BeautifulSoup(r3.text,features=lxml)
        img_url = str(soup.find(div,class_=main-image).find(img).get(src))
        # 添加请求头应对图片防盗链
        r4 = requests.get(url=img_url,
                    headers={Referer:url_new})
        # print(type(img_url))
        dict = img_url.rsplit(/,maxsplit=1)
        file_name = os.path.join(path,dict[1])
        # print(file_name)
        with open(file_name,wb) as f:
            f.write(r4.content)

1.3 模拟登录choti网站并点赞

import requests
from fake_useragent import UserAgent

agent = UserAgent()
# ############## 方式一 ##############
"""
## 1、首先登陆任何页面,获取cookie
i1 = requests.get(url="https://dig.chouti.com/",
                  headers={
                      "User-Agent":agent.random,
                  })
i1_cookies = i1.cookies.get_dict()
print(i1_cookies)

# ## 2、用户登陆,携带上一次的cookie,后台对cookie中的 gpsd 进行授权
i2 = requests.post(
    url="https://dig.chouti.com/login",
    data={
        ‘phone‘: "8615057101356",
        ‘password‘: "199SulkyBuckets",
        ‘oneMonth‘: "1"
    },
    headers={"User-Agent":agent.random,},
    cookies=i1_cookies,
)

# ## 3、点赞(只需要携带已经被授权的gpsd即可)

i3 = requests.post(
    url="https://dig.chouti.com/link/vote?linksId=19444596",
    headers={"User-Agent":agent.random,},
    cookies=i1_cookies,
)
print(i3.text)
"""

# ############## 方式二 ##############

# import requests

session = requests.Session()
i1 = session.get(url="https://dig.chouti.com",
                 headers={"User-Agent": agent.random})
i2 = session.post(
    url="https://dig.chouti.com/login",
    data={
        phone: "8615057101356",
        password: "199SulkyBuckets",
        oneMonth: "1"
    },
    headers={"User-Agent": agent.random}
)
i3 = session.post(
    url="https://dig.chouti.com/link/vote?linksId=19444596",
    headers={"User-Agent": agent.random}
)
print(i3.text)

2.Scrapy框架

 

Scrapy是一个为了爬取网站数据,提取结构性数据而编写的应用框架。 其可以应用在数据挖掘,信息处理或存储历史数据等一系列的程序中。
其最初是为了页面抓取 (更确切来说, 网络抓取 )所设计的, 也可以应用在获取API所返回的数据(例如 Amazon Associates Web Services ) 或者通用的网络爬虫。Scrapy用途广泛,可以用于数据挖掘、监测和自动化测试。

 

Scrapy 使用了 Twisted异步网络库来处理网络通讯。整体架构大致如下

技术分享图片

Scrapy主要包括了以下组件:

  • 引擎(Scrapy)
    用来处理整个系统的数据流处理, 触发事务(框架核心)
  • 调度器(Scheduler)
    用来接受引擎发过来的请求, 压入队列中, 并在引擎再次请求的时候返回. 可以想像成一个URL(抓取网页的网址或者说是链接)的优先队列, 由它来决定下一个要抓取的网址是什么, 同时去除重复的网址
  • 下载器(Downloader)
    用于下载网页内容, 并将网页内容返回给蜘蛛(Scrapy下载器是建立在twisted这个高效的异步模型上的)
  • 爬虫(Spiders)
    爬虫是主要干活的, 用于从特定的网页中提取自己需要的信息, 即所谓的实体(Item)。用户也可以从中提取出链接,让Scrapy继续抓取下一个页面
  • 项目管道(Pipeline)
    负责处理爬虫从网页中抽取的实体,主要的功能是持久化实体、验证实体的有效性、清除不需要的信息。当页面被爬虫解析后,将被发送到项目管道,并经过几个特定的次序处理数据。
  • 下载器中间件(Downloader Middlewares)
    位于Scrapy引擎和下载器之间的框架,主要是处理Scrapy引擎与下载器之间的请求及响应。
  • 爬虫中间件(Spider Middlewares)
    介于Scrapy引擎和爬虫之间的框架,主要工作是处理蜘蛛的响应输入和请求输出。
  • 调度中间件(Scheduler Middewares)
    介于Scrapy引擎和调度之间的中间件,从Scrapy引擎发送到调度的请求和响应。

Scrapy运行流程大概如下:

    1. 引擎从调度器中取出一个链接(URL)用于接下来的抓取
    2. 引擎把URL封装成一个请求(Request)传给下载器
    3. 下载器把资源下载下来,并封装成应答包(Response)
    4. 爬虫解析Response
    5. 解析出实体(Item),则交给实体管道进行进一步的处理
    6. 解析出的是链接(URL),则把URL交给调度器等待抓取

2.1 基本命令

1. scrapy startproject 项目名称
   - 在当前目录中创建中创建一个项目文件(类似于Django)
 
2. scrapy genspider [-t template] <name> <domain>
   - 创建爬虫应用
   如:
      scrapy gensipider -t basic oldboy oldboy.com
      scrapy gensipider -t xmlfeed autohome autohome.com.cn
   PS:
      查看所有命令:scrapy gensipider -l
      查看模板命令:scrapy gensipider -d 模板名称
 
3. scrapy list
   - 展示爬虫应用列表
 
4. scrapy crawl 爬虫应用名称 --nolog(无运行日志显示)
   - 运行单独爬虫应用

2.2 选择器SELECTOR

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from scrapy.selector import Selector, htmlXPathSelector
from scrapy.http import HtmlResponse
html = """<!DOCTYPE html>
<html>
    <head lang="en">
        <meta charset="UTF-8">
        <title></title>
    </head>
    <body>
        <ul>
            <li class="item-"><a id=‘i1‘ href="link.html">first item</a></li>
            <li class="item-0"><a id=‘i2‘ href="llink.html">first item</a></li>
            <li class="item-1"><a href="llink2.html">second item<span>vv</span></a></li>
        </ul>
        <div><a href="llink2.html">second item</a></div>
    </body>
</html>
"""
response = HtmlResponse(url=http://example.com, body=html,encoding=utf-8)
# hxs = HtmlXPathSelector(response)
# print(hxs)
# hxs = Selector(response=response).xpath(‘//a‘)
# print(hxs)
# hxs = Selector(response=response).xpath(‘//a[2]‘)
# print(hxs)
# hxs = Selector(response=response).xpath(‘//a[@id]‘)
# print(hxs)
# hxs = Selector(response=response).xpath(‘//a[@id="i1"]‘)
# print(hxs)
# hxs = Selector(response=response).xpath(‘//a[@href="link.html"][@id="i1"]‘)
# print(hxs)
# hxs = Selector(response=response).xpath(‘//a[contains(@href, "link")]‘)
# print(hxs)
# hxs = Selector(response=response).xpath(‘//a[starts-with(@href, "link")]‘)
# print(hxs)
# hxs = Selector(response=response).xpath(‘//a[re:test(@id, "i\\d+")]‘)
# print(hxs)
# hxs = Selector(response=response).xpath(‘//a[re:test(@id, "i\\d+")]/text()‘).extract()
# print(hxs)
# hxs = Selector(response=response).xpath(‘//a[re:test(@id, "i\\d+")]/@href‘).extract()
# print(hxs)
# hxs = Selector(response=response).xpath(‘/html/body/ul/li/a/@href‘).extract()
# print(hxs)
# hxs = Selector(response=response).xpath(‘//body/ul/li/a/@href‘).extract_first()
# print(hxs)
 
# ul_list = Selector(response=response).xpath(‘//body/ul/li‘)
# for item in ul_list:
#     v = item.xpath(‘./a/span‘)
#     # 或
#     # v = item.xpath(‘a/span‘)
#     # 或
#     # v = item.xpath(‘*/a/span‘)
#     print(v)

chouti 自动登入点赞

import scrapy
from scrapy.selector import HtmlXPathSelector
from scrapy.http.request import Request
from scrapy.http.cookies import CookieJar
from scrapy import FormRequest


class ChouTiSpider(scrapy.Spider):
    # 爬虫应用的名称,通过此名称启动爬虫命令
    name = "chouti"
    # 允许的域名
    allowed_domains = ["chouti.com"]

    cookie_dict = {}
    has_request_set = {}
    # 重写起始函数
    def start_requests(self):
        url = http://dig.chouti.com/
        # return [Request(url=url, callback=self.login)]
        yield Request(url=url, callback=self.login)

    def login(self, response):
        cookie_jar = CookieJar()
        cookie_jar.extract_cookies(response, response.request)
        for k, v in cookie_jar._cookies.items():
            for i, j in v.items():
                for m, n in j.items():
                    self.cookie_dict[m] = n.value
        print(self.cookie_dict)
        req = Request(
            url=http://dig.chouti.com/login,
            method=POST,
            headers={Content-Type: application/x-www-form-urlencoded; charset=UTF-8},
            body=phone=8615057101356&password=199SulkyBuckets&Month=1,
            cookies=self.cookie_dict,
            callback=self.check_login
        )
        yield req

    def check_login(self, response):
        # print(response.text)
        req = Request(
            url=http://dig.chouti.com/,
            method=GET,
            callback=self.show,
            cookies=self.cookie_dict,
            dont_filter=True
        )
        yield req

    def show(self, response):
        # print(response.text)
        hxs = HtmlXPathSelector(response)
        news_list = hxs.select(//div[@id="content-list"]/div[@class="item"])
        for new in news_list:
            # temp = new.xpath(‘div/div[@class="part2"]/@share-linkid‘).extract()
            link_id = new.xpath(*/div[@class="part2"]/@share-linkid).extract_first()
            yield Request(
                url=http://dig.chouti.com/link/vote?linksId=%s %(link_id,),
                method=POST,
                cookies=self.cookie_dict,
                callback=self.do_favor
            )

        # page_list = hxs.select(‘//div[@id="dig_lcpage"]//a[re:test(@href, "/all/hot/recent/\\d+")]/@href‘).extract()
        # for page in page_list:
        #
        #     page_url = ‘http://dig.chouti.com%s‘ % page
        #     import hashlib
        #     hash = hashlib.md5()
        #     hash.update(bytes(page_url,encoding=‘utf-8‘))
        #     key = hash.hexdigest()
        #     if key in self.has_request_set:
        #         pass
        #     else:
        #         self.has_request_set[key] = page_url
        #         yield Request(
        #             url=page_url,
        #             method=‘GET‘,
        #             callback=self.show
        #         )

    def do_favor(self, response):
        print(response.text)

注意:settings.py中设置DEPTH_LIMIT = 1来指定“递归”的层数。注意:settings.py中设置DEPTH_LIMIT = 1来指定“递归”的层数。

多次爬取同一个页面注意设置REQUEST:dont_filter=True,防止爬虫自行去重

 2.3 避免重复访问

scrapy默认使用 scrapy.dupefilter.RFPDupeFilter 进行去重,相关配置有:

DUPEFILTER_CLASS = scrapy.dupefilter.RFPDupeFilter
DUPEFILTER_DEBUG = False
JOBDIR = "保存范文记录的日志路径,如:/root/"  # 最终路径为 /root/requests.seen

2.4 爬取mzitu图片

技术分享图片
# -*- coding: utf-8 -*-
import scrapy
from scrapy.http import Request
from scrapy.selector import Selector,XmlXPathSelector
from ..items import MzituItem

class MeizituSpider(scrapy.Spider):
    name = meizitu
    allowed_domains = [mzitu.com]
    # start_urls = [‘http://mzitu.com/‘]

    def start_requests(self):
        url = http://www.mzitu.com/all/
        yield Request(url=url,method=GET,callback=self.main_page)

    def main_page(self,response):
        # 取得所有套图地址
        hxs = Selector(response = response).xpath(//p[contains(@class,"url")]/a/@href).extract()
        for url in hxs:
            req = Request(url = url,
                          callback=self.fenye)
            yield req

    def fenye(self,response):
        # 取得图片路径和标题
        img_url = Selector(response=response).xpath(//div[@class="main-image"]//img/@src).extract_first().strip()
        title = Selector(response=response).xpath(//div[@class="main-image"]//img/@alt).extract_first().strip()
        yield MzituItem(img_url=img_url,title=title)
        # 取得下方导航条页面路径
        xhs = Selector(response=response).xpath(//div[@class="pagenavi"]/a/@href).extract()
        for url in xhs:
            req = Request(
                url=url,
                callback=self.fenye,
            )
            yield req
meizitu.py
技术分享图片
import scrapy
class MzituItem(scrapy.Item):
    # define the fields for your item here like:
    img_url = scrapy.Field()
    title = scrapy.Field()
items
技术分享图片
from scrapy.exceptions import DropItem
import requests,os
base_path = F:\\mzitu
class MzituPipeline(object):
    def process_item(self, item, spider):
        # print(item[‘title‘],item[‘img_url‘])
        title = item[title]
        url = str(item[img_url])
        if os.path.exists(os.path.join(base_path,item[title])):
            pass
        else:
            os.makedirs(os.path.join(base_path,item[title]))
        dict = url.rsplit(/, maxsplit=1)
        file_name = os.path.join(base_path,title,dict[1])

        if os.path.exists(file_name):
            pass
        else:
            response = requests.get(url=url, headers={Referer: http://www.mzitu.com/net/})
            print(正在下载, title, ......)
            with open(file_name,wb) as f:
                f.write(response.content)
            print(下载完成.)
        raise DropItem()
piplines
技术分享图片
ITEM_PIPELINES = {
   mzitu.pipelines.MzituPipeline: 300,
}

#去重,以及设定深度
DEPTH_LIMIT = 3
DUPEFILTER_CLASS = scrapy.dupefilter.RFPDupeFilter
DUPEFILTER_DEBUG = False
settings

2.5 其他

技术分享图片
# -*- coding: utf-8 -*-

# Scrapy settings for step8_king project
#
# For simplicity, this file contains only settings considered important or
# commonly used. You can find more settings consulting the documentation:
#
#     http://doc.scrapy.org/en/latest/topics/settings.html
#     http://scrapy.readthedocs.org/en/latest/topics/downloader-middleware.html
#     http://scrapy.readthedocs.org/en/latest/topics/spider-middleware.html

# 1. 爬虫名称
BOT_NAME = step8_king

# 2. 爬虫应用路径
SPIDER_MODULES = [step8_king.spiders]
NEWSPIDER_MODULE = step8_king.spiders

# Crawl responsibly by identifying yourself (and your website) on the user-agent
# 3. 客户端 user-agent请求头
# USER_AGENT = ‘step8_king (+http://www.yourdomain.com)‘

# Obey robots.txt rules
# 4. 禁止爬虫配置
# ROBOTSTXT_OBEY = False

# Configure maximum concurrent requests performed by Scrapy (default: 16)
# 5. 并发请求数
# CONCURRENT_REQUESTS = 4

# Configure a delay for requests for the same website (default: 0)
# See http://scrapy.readthedocs.org/en/latest/topics/settings.html#download-delay
# See also autothrottle settings and docs
# 6. 延迟下载秒数
# DOWNLOAD_DELAY = 2


# The download delay setting will honor only one of:
# 7. 单域名访问并发数,并且延迟下次秒数也应用在每个域名
# CONCURRENT_REQUESTS_PER_DOMAIN = 2
# 单IP访问并发数,如果有值则忽略:CONCURRENT_REQUESTS_PER_DOMAIN,并且延迟下次秒数也应用在每个IP
# CONCURRENT_REQUESTS_PER_IP = 3

# Disable cookies (enabled by default)
# 8. 是否支持cookie,cookiejar进行操作cookie
# COOKIES_ENABLED = True
# COOKIES_DEBUG = True

# Disable Telnet Console (enabled by default)
# 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‘,
# }


# Configure item pipelines
# See http://scrapy.readthedocs.org/en/latest/topics/item-pipeline.html
# 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‘


# Enable and configure the AutoThrottle extension (disabled by default)
# See http://doc.scrapy.org/en/latest/topics/autothrottle.html

"""
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
"""

# 开始自动限速
# AUTOTHROTTLE_ENABLED = True
# The initial download delay
# 初始下载延迟
# AUTOTHROTTLE_START_DELAY = 5
# The maximum download delay to be set in case of high latencies
# 最大下载延迟
# AUTOTHROTTLE_MAX_DELAY = 10
# The average number of requests Scrapy should be sending in parallel to each remote server
# 平均每秒并发数
# AUTOTHROTTLE_TARGET_CONCURRENCY = 1.0

# Enable showing throttling stats for every response received:
# 是否显示
# AUTOTHROTTLE_DEBUG = True

# Enable and configure HTTP caching (disabled by default)
# See http://scrapy.readthedocs.org/en/latest/topics/downloader-middleware.html#httpcache-middleware-settings


"""
18. 启用缓存
    目的用于将已经发送的请求或相应缓存下来,以便以后使用
    
    from scrapy.downloadermiddlewares.httpcache import HttpCacheMiddleware
    from scrapy.extensions.httpcache import DummyPolicy
    from scrapy.extensions.httpcache import FilesystemCacheStorage
"""
# 是否启用缓存策略
# HTTPCACHE_ENABLED = True

# 缓存策略:所有请求均缓存,下次在请求直接访问原来的缓存即可
# HTTPCACHE_POLICY = "scrapy.extensions.httpcache.DummyPolicy"
# 缓存策略:根据Http响应头:Cache-Control、Last-Modified 等进行缓存的策略
# HTTPCACHE_POLICY = "scrapy.extensions.httpcache.RFC2616Policy"

# 缓存超时时间
# HTTPCACHE_EXPIRATION_SECS = 0

# 缓存保存路径
# HTTPCACHE_DIR = ‘httpcache‘

# 缓存忽略的Http状态码
# HTTPCACHE_IGNORE_HTTP_CODES = []

# 缓存存储的插件
# HTTPCACHE_STORAGE = ‘scrapy.extensions.httpcache.FilesystemCacheStorage‘


"""
19. 代理,需要在环境变量中设置
    from scrapy.contrib.downloadermiddleware.httpproxy import HttpProxyMiddleware
    
    方式一:使用默认
        os.environ
        {
            http_proxy:http://root:[email protected]:9999/
            https_proxy:http://192.168.11.11:9999/
        }
    方式二:使用自定义下载中间件
    
    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‘])
    
    DOWNLOADER_MIDDLEWARES = {
       ‘step8_king.middlewares.ProxyMiddleware‘: 500,
    }
    
"""

"""
20. 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

"""



"""
21. 爬虫中间件
    class SpiderMiddleware(object):

        def process_spider_input(self,response, spider):
            ‘‘‘
            下载完成,执行,然后交给parse处理
            :param response: 
            :param spider: 
            :return: 
            ‘‘‘
            pass
    
        def process_spider_output(self,response, result, spider):
            ‘‘‘
            spider处理完成,返回时调用
            :param response:
            :param result:
            :param spider:
            :return: 必须返回包含 Request 或 Item 对象的可迭代对象(iterable)
            ‘‘‘
            return result
    
        def process_spider_exception(self,response, exception, spider):
            ‘‘‘
            异常调用
            :param response:
            :param exception:
            :param spider:
            :return: None,继续交给后续中间件处理异常;含 Response 或 Item 的可迭代对象(iterable),交给调度器或pipeline
            ‘‘‘
            return None
    
    
        def process_start_requests(self,start_requests, spider):
            ‘‘‘
            爬虫启动时调用
            :param start_requests:
            :param spider:
            :return: 包含 Request 对象的可迭代对象
            ‘‘‘
            return start_requests
    
    内置爬虫中间件:
        ‘scrapy.contrib.spidermiddleware.httperror.HttpErrorMiddleware‘: 50,
        ‘scrapy.contrib.spidermiddleware.offsite.OffsiteMiddleware‘: 500,
        ‘scrapy.contrib.spidermiddleware.referer.RefererMiddleware‘: 700,
        ‘scrapy.contrib.spidermiddleware.urllength.UrlLengthMiddleware‘: 800,
        ‘scrapy.contrib.spidermiddleware.depth.DepthMiddleware‘: 900,

"""
# from scrapy.contrib.spidermiddleware.referer import RefererMiddleware
# Enable or disable spider middlewares
# See http://scrapy.readthedocs.org/en/latest/topics/spider-middleware.html
SPIDER_MIDDLEWARES = {
   # ‘step8_king.middlewares.SpiderMiddleware‘: 543,
}


"""
22. 下载中间件
    class DownMiddleware1(object):
        def process_request(self, request, spider):
            ‘‘‘
            请求需要被下载时,经过所有下载器中间件的process_request调用
            :param request:
            :param spider:
            :return:
                None,继续后续中间件去下载;
                Response对象,停止process_request的执行,开始执行process_response
                Request对象,停止中间件的执行,将Request重新调度器
                raise IgnoreRequest异常,停止process_request的执行,开始执行process_exception
            ‘‘‘
            pass
    
    
    
        def process_response(self, request, response, spider):
            ‘‘‘
            spider处理完成,返回时调用
            :param response:
            :param result:
            :param spider:
            :return:
                Response 对象:转交给其他中间件process_response
                Request 对象:停止中间件,request会被重新调度下载
                raise IgnoreRequest 异常:调用Request.errback
            ‘‘‘
            print(‘response1‘)
            return response
    
        def process_exception(self, request, exception, spider):
            ‘‘‘
            当下载处理器(download handler)或 process_request() (下载中间件)抛出异常
            :param response:
            :param exception:
            :param spider:
            :return:
                None:继续交给后续中间件处理异常;
                Response对象:停止后续process_exception方法
                Request对象:停止中间件,request将会被重新调用下载
            ‘‘‘
            return None

    
    默认下载中间件
    {
        ‘scrapy.contrib.downloadermiddleware.robotstxt.RobotsTxtMiddleware‘: 100,
        ‘scrapy.contrib.downloadermiddleware.httpauth.HttpAuthMiddleware‘: 300,
        ‘scrapy.contrib.downloadermiddleware.downloadtimeout.DownloadTimeoutMiddleware‘: 350,
        ‘scrapy.contrib.downloadermiddleware.useragent.UserAgentMiddleware‘: 400,
        ‘scrapy.contrib.downloadermiddleware.retry.RetryMiddleware‘: 500,
        ‘scrapy.contrib.downloadermiddleware.defaultheaders.DefaultHeadersMiddleware‘: 550,
        ‘scrapy.contrib.downloadermiddleware.redirect.MetaRefreshMiddleware‘: 580,
        ‘scrapy.contrib.downloadermiddleware.httpcompression.HttpCompressionMiddleware‘: 590,
        ‘scrapy.contrib.downloadermiddleware.redirect.RedirectMiddleware‘: 600,
        ‘scrapy.contrib.downloadermiddleware.cookies.CookiesMiddleware‘: 700,
        ‘scrapy.contrib.downloadermiddleware.httpproxy.HttpProxyMiddleware‘: 750,
        ‘scrapy.contrib.downloadermiddleware.chunked.ChunkedTransferMiddleware‘: 830,
        ‘scrapy.contrib.downloadermiddleware.stats.DownloaderStats‘: 850,
        ‘scrapy.contrib.downloadermiddleware.httpcache.HttpCacheMiddleware‘: 900,
    }

"""
# from scrapy.contrib.downloadermiddleware.httpauth import HttpAuthMiddleware
# Enable or disable downloader middlewares
# See http://scrapy.readthedocs.org/en/latest/topics/downloader-middleware.html
# DOWNLOADER_MIDDLEWARES = {
#    ‘step8_king.middlewares.DownMiddleware1‘: 100,
#    ‘step8_king.middlewares.DownMiddleware2‘: 500,
# }

settings
配置文件

 












以上是关于Requests爬虫和scrapy框架多线程爬虫的主要内容,如果未能解决你的问题,请参考以下文章

爬虫实战利用scrapy框架爬取豆瓣图书信息

python链家网高并发异步爬虫and异步存入数据

网络爬虫 初了解

Scrapy爬虫

高效的Scrapy爬虫框架干货教程,请查收!

Scrapy学习-