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

配置文件

原文地址：https://www.cnblogs.com/blue-day/p/9062715.html

时间： 2024-09-28 01:07:32

Requests爬虫和scrapy框架多线程爬虫的相关文章

网络爬虫之scrapy框架详解,scrapy框架设置代理

twisted介绍 Twisted是用Python实现的基于事件驱动的网络引擎框架,scrapy正是依赖于twisted, 它是基于事件循环的异步非阻塞网络框架,可以实现爬虫的并发. twisted是什么以及和requests的区别: request是一个python实现的可以伪造浏览器发送Http请求的模块,它封装了socket发送请求 twisted是基于时间循环的异步非阻塞的网络框架,它也封装了socket发送请求,但是他可以单线程的完成并发请求. twisted的特点是: 非阻塞:不等待

Python爬虫进阶(Scrapy框架爬虫)

准备工作:           配置环境问题什么的我昨天已经写了,那么今天直接安装三个库                        首先第一步:                            (我们要用到scrapy框架,在python里调用windows 命令,使用mongodb存储爬到的数据 )                                  进入DOS python/Script>路径下  输入命令: python/Script> pip install p

Python网络爬虫之Scrapy框架（CrawlSpider）

目录 Python网络爬虫之Scrapy框架(CrawlSpider) CrawlSpider使用 爬取糗事百科糗图板块的所有页码数据 Python网络爬虫之Scrapy框架(CrawlSpider) 提问:如果想要通过爬虫程序去爬取"糗百"全站数据新闻数据的话,有几种实现方法? 方法一:基于Scrapy框架中的Spider的递归爬取进行实现(Request模块递归回调parse方法). 方法二:基于CrawlSpider的自动爬取进行实现(更加简洁和高效). CrawlSpider使

爬虫学习 16.Python网络爬虫之Scrapy框架（CrawlSpider）

爬虫学习 16.Python网络爬虫之Scrapy框架(CrawlSpider) 引入 提问:如果想要通过爬虫程序去爬取"糗百"全站数据新闻数据的话,有几种实现方法? 方法一:基于Scrapy框架中的Spider的递归爬取进行实现(Request模块递归回调parse方法). 方法二:基于CrawlSpider的自动爬取进行实现(更加简洁和高效). 今日概要 CrawlSpider简介 CrawlSpider使用 基于CrawlSpider爬虫文件的创建 链接提取器 规则解析器 今日详

python爬虫随笔-scrapy框架(1)——scrapy框架的安装和结构介绍

scrapy框架简介 Scrapy,Python开发的一个快速.高层次的屏幕抓取和web抓取框架,用于抓取web站点并从页面中提取结构化的数据.Scrapy用途广泛,可以用于数据挖掘.监测和自动化测试.(引用自:百度百科) scrapy官方网站:https://scrapy.org/ scrapy官方文档:https://doc.scrapy.org/en/latest/ scrapy框架安装 首先我们安装scrapy,使用如下命令 pip install scrapy 此时很多人应该都会遇到如

爬虫之scrapy框架

1.scrapy框架介绍 Scrapy是用纯Python实现的一个为了爬取网站数据.提取结构性数据而编写的应用框架 Scrapy 特色是使用了 Twisted异步网络框架来处理网络通讯,加快了下载速度,不用自己去实现异步框架,并且包含了各种中间件接口,可以灵活的完成各种需求 1.1 scrapy框架架构图 Scrapy Engine(引擎): 负责Spider.ItemPipeline.Downloader.Scheduler中间的通讯,信号.数据传递等. Scheduler(调度器): 它负责

5 爬虫之scrapy框架

一 scrapy框架简介 1 介绍 Scrapy一个开源和协作的框架,其最初是为了页面抓取 (更确切来说, 网络抓取 )所设计的,使用它可以以快速.简单.可扩展的方式从网站中提取所需的数据.但目前Scrapy的用途十分广泛,可用于如数据挖掘.监测和自动化测试等领域,也可以应用在获取API所返回的数据(例如 Amazon Associates Web Services ) 或者通用的网络爬虫.Scrapy 是基于twisted框架开发而来,twisted是一个流行的事件驱动的python网络框架.

web爬虫讲解—Scrapy框架爬虫—Scrapy安装—Scrapy指令

Scrapy框架安装 1.首先,终端执行命令升级pip: python -m pip install --upgrade pip2.安装,wheel(建议网络安装) pip install wheel3.安装,lxml(建议下载安装)4.安装,Twisted(建议下载安装)5.安装,Scrapy(建议网络安装) pip install Scrapy 测试Scrapy是否安装成功 Scrapy框架指令 scrapy -h 查看帮助信息 Available commands: bench Run q

09 Scrapy框架在爬虫中的使用

一.简介 Scrapy是一个为了爬取网站数据,提取结构性数据而编写的应用框架.它集成高性能异步下载,队列,分布式,解析,持久化等. Scrapy 是基于twisted框架开发而来,twisted是一个流行的事件驱动的python网络框架.因此Scrapy使用了一种非阻塞(又名异步)的代码来实现并发.它是爬虫界最知名的框架.就好比web框架中的django.Scrapy之所以能实现异步,得益于twisted框架.twisted有事件队列,哪一个事件有活动,就会执行! 1. 安装 Linux:pip