############################ requests的使用

import requests

# 发送请求， 使用的函数按照HTTP访问的方法，主要：get、post、put、delete、head、options，patch

# 最终都是调用了request函数，这个函数的原型是： def request(method, url, **kwargs):

# kwargs可以填入：headers, params, data, json， proxies

response = requests.get('https://www.baidu.com')

# 返回的对象是 requests.models.Response

# response对象通常有以下几个方法：

response.status_code # 状态码

response.request.headers # 对应请求的请求头

response.headers # 响应头

response.encoding # 默认解码方式，修改之前默认是ISO-8859-1

response.text # 按照response.encoding 解码的str

response.content # bytes

print(response.content.decode('utf-8'))

######## 保持会话进行爬取，每次请求都会带上cookie

session = requests.session() # requests.sessions.Session类型

response = session.get(url,headers)

####### 小技巧

cookie转为字典 requests.util.dict_from_cookiejar

https请求不进行ssl验证 requests.get('https://www.baidu.com', verify=False)

设置超时 requests.get(url, 1)

################################### 正向代理和反向代理

代理为谁服务就隐藏谁的信息。

正向代理：代理为客户端服务，产生的结果是：服务端不知道真正的客户端

反向代理：代理为服务端服务，并对服务集群做负载均衡，将请求均衡分配到空闲服务器，

产生的结果是：客户端不知道真正的服务器。

nginx服务器的作用

1.C-S架构模式解耦，他是一个中间层，可以随时更改绑定的服务器

2.负载均衡，避免请求拥塞，提升并发量

3.反向代理，配合服务器集群提供了按照配置、服务地区的最有服务

CDN都是反向代理的应用，但他们都不代表反向代理

1. 内容分发网络CDN, 通过反向代理把请求分发到世界各地的服务器去, 提升访问速度.

2. 大公司不想暴露自己主服务器的位置.

阿里云CDN配置------

https://help.aliyun.com/document_detail/27112.html

1.到CDN控制台添加域名

指定业务类型：（多选）全站加速、图片小文件、大文件、音视频点播、直播流媒体、移动加速

指定源站类型：OSS域名 IP 源站域名

2.域名管理：配置CNAME

复制CNAME， 到DNS服务商控制台，添加一条CNAME记录

################################ 关于反爬

1.拒绝请求：

①User-Agent 反反爬： 准备User-Agent池

②Host、Referer 反反爬：修改Header，复制浏览器访问时的内容

③Cookie：反反爬：使用浏览器Cookie， 保持会话request使用session或直接使用selenium

需要登录：准备多个账号， 单独使用程序实现登录保存cookie， 爬虫程序读取cookie发送请求

不需要登录：单独使用程序实现登录保存cookie， 爬虫程序读取cookie发送请求

④ip， 反反爬：使用ip池，使用代理

2.数据干扰

①伪装：如请求的明明是JSON，但返回image，再通过js解密数据,

通常可以通过js代码得到解密方法；如果不能，只能爬取网页。

②加密：如果不能轻易破解接口加密，只能通过爬取网页了。

③自定义字体：通常用来干扰数字数据，下载字体下来，建立对应关系(手动或者fontmeta)，并在爬虫程序中通过对应关系还原。

############################## 数据提取过程， 由容易到复杂

############# 数据提取概述

非结构化的数据：html等

处理方法：正则表达式、xpath----->将提取的信息字符串构造Python类型

结构化数据：json，xml等

处理方法：转化为python数据类型---->利用三方库直接转换为Python类型

############# 具体的数据提取过程

1.如果有ajax请求的JSON数据，可直接使用，通常这种数据有两种形式：

①pure JSON形式

②带回调形式的JSON，通常是xxxx(JSON)的形式

可以通过使用正则进一步提取，有的可以直接将请求参数中的callback参数直接去掉，去掉之后直接返回pure JSON

③接口请求过来一段字符串，类似于字典格式，但是不是标准JSON，其中某个字段的值是JSON，可以通过re提取。

手机页面的数据经常使用JSON

# re.compile（编译）

# pattern.match（从头找一个

# pattern.search（找一个）

# pattern.findall（找所有）

# pattern.sub（替换

# 元字符“.”在默认模式下，匹配除换行符外的所有字符。在DOTALL模式下，匹配所有字符，包括换行符

# 通过正则表达式匹配内涵段子的段子

#  http://neihanshequ.com/

# 获取http://36kr.com/网站首页的所有新闻

2.处理HTML页面：

①xpath：

xpath 使用的lxml这个HTML/XML解析器实现，可以使用xpath的语法定位特定元素以及获取节点信息，常用语法

nodename: 节点名称

/ 从根节点选取

// 当前节点

. 选取当前节点

.. 当前节点的父节点

@ 选取属性

//title[@lang] 拥有属性lang的title元素

//title[@lang='eng'] 拥有值为eng的lang属性的title元素

### 数组操作

/bookstore/book[1] 第一个book元素

/bookstore/book[last()] 最后一个book元素

/bookstore/book[position()<3] 前2个

/bookstore/book[price>35.00] # price标签文本值>35.00的book元素

# 通配符

*任何元素节点

@*任何属性节点

node() 任何节点 相当于 * 和 @* 之和

############## xpath 配合Python使用

from lxml import etree

element = etree.HTML(html_str)

script = element.xpath(

'//div[@class="scontent" and @id="bofqi"]/script/text()')

# 1、爬取糗事百科段子，页面的URL是

#  http://www.qiushibaike.com/8hr/page/1

# 2、动手把上述的爬虫改为多线程爬虫

3.动态页面处理，通常是根据登录用户的信息不同而提供不同的页面数据。

这类信息的爬取，首先要进行登录：登录过程分为以下几种：

⑴没有验证码：

情况一：登录字段没有加密或者非常容易看出加密手段：直接向表单提交地址发送请求(GitHub)

情况二：登录字段加密手段无法破解：selenium

⑵验证码刷新不改变：

主要原理是：获取验证码图片的接口，判断携带的cookie相同就返回相同的验证码

情况一：requests + 识图工具

情况二：使用selenium + 识图工具(如云打码）可直接传递验证码图片的url

⑶验证码刷新改变：（百度、钱多多 http://qian.sicent.com/Login/code.do ）

原理：

如果是动态获取的图片：ajax请求参数或者header会不同，这个可以通过对比参数查看(百度)

如果是header和参数都相同，两次请求的图片依然不同，那么能够将登陆操作和验证码关联的就只有ip、

session等信息了。大部分情况是使用了缓存服务器存储了session-id对应的code，但每次获取验证码都会更改它。

情况一：requests + 识图工具，不能直接使用图片的url，必须下载下来再上传识图

情况二：selenium + 识图工具，不能直接使用图片的url，必须下载下来再上传识图

登录之后如何保持登录状态：

①requests直接使用session保持会话爬取

②每次请求都携带登录之后传递的cookie，这样无法使用动态cookie，

有错误的情况，可能在某个页面请求之后cookie更改

③使用Scrapy如何保持登录状态

下载器中间件CookiesMiddleware

class scrapy.downloadermiddlewares.cookies.CookiesMiddleware

该中间件使得爬取需要cookie(例如使用session)的网站成为了可能。

其追踪了web server发送的cookie，并在之后的request中发送回去， 就如浏览器所做的那样。

https://scrapy-chs.readthedocs.io/zh_CN/1.0/topics/downloader-middleware.html#module-scrapy.downloadermiddlewares.cookies

####### selenium使用和注意点

①基本使用

from selenium import webdriver

driver = webdriver.Chrome()

tag = driver.find_elements_by_xpath('') # list 或者 selenium.webdriver.remote.webelement.WebElement

# driver.switch_to.frame()

# driver.save_screenshot

# driver.delete_cookie("CookieName")

# driver.delete_all_cookies()

2.定位元素

find_element_by_id(返回一个)

find_elements_by_xpath （返回一个列表）

find_elements_by_link_text

find_elements_by_partial_link_text

find_elements_by_tag_name

find_elements_by_class_name

find_elements_by_css_selector

3.查看页面相关信息

# driver.page_source

# driver.get_cookies()

# driver.current_url

4.关闭

# driver.close() #退出当前页面

# driver.quit() #退出浏览器

②获取登陆后的cookie

{cookie[‘name’]: cookie[‘value’] for cookie in driver.get_cookies()}

③页面等待

time.sleep(10)

########

# 1.豆瓣登陆

# 2.爬取斗鱼直播平台的所有房间信息

# https://www.douyu.com/directory/all

4.几种常见的页面数据组织形式：

初始页 + ajax请求的JSON (有道词典)

初始页 + ajax请求的HTML片段 （百度贴吧首页下拉、京东搜索下拉）

初始页 + iframe (QQ邮箱登录，网易云音乐)

################################ 数据清洗

数据的完整性----例如人的属性中缺少性别、籍贯、年龄等

数据的唯一性----例如不同来源的数据出现重复的情况

数据的权威性----例如同一个指标出现多个来源的数据，且数值不一样

数据的合法性----例如获取的数据与常识不符，年龄大于150岁

数据的一致性----例如不同来源的不同指标，实际内涵是一样的，或是同一指标内涵不一致

##### 技术实现

################################ 数据去重

url去重的场景：

一次性爬取的数据，短期内同一url数据不会改变，可以通过url去重。

长期爬取的数据，如果网站url本身是静态的，要注意筛选是否是伪静态url的网站，也可以直接通过url去重。

其它数据去重场景：

①数据入库阶段去重：

单个字段：比如url

通过数据本身：建立联合索引（用户id,发帖日期，数据来源）

②数据入库前去重：

①请求去重：

思路一：url去重(使用情况：url对应一条数据不会变的情况):

方法一：把url地址存在redis的集合中，后续根据url是否存在于redis的集合中，来判断数据是否抓过

方法二：布隆过滤器(适用于文章内容去重)是一种位操作，使用10个算法给每个url地址生成10个值，每个值代表一个位置，拿到一个url地址，先取10个位置的值，如果全为1，表示url地址存在，如果不全为1，表示url地址不存在，对应的往该位置置位1

思路二：url+headers去重(Scrapy-redis实现)

②数据去重：

思路一：Hash去重

1.选择数据中的关键字段，使用hash方法（md5,sha1,）把关键字段进行加密，生成字符串

2.把字符串存入redis的集合中

如果抓过，更新对应的数据，没有抓过，插入

########################################## Scrapy 概况

1.「Scrapy Engine(引擎)

总指挥: 负责数据和信号的在不同模块间的传递

scrapy已经实现,

2.Scheduler(调度器)

一个队列，存放引擎发过来的request请求

scrapy 已经实现

3.Downloader (下载器)

下载把引擎发过来的requests请求，并返回给引擎

scrapy 已经实现

4.Spider (爬虫)

处理引擎发来来的response,提取数据，提取url,并交给引擎

需要手写

5.Item Pipeline(管道)

处理引擎传过来的数据，比如存储

需要手写

6.DownloaderMiddlewares(下载中间件)

可以自定义的下载扩展，比如设置代理

一般不用手写

7.(SpiderMiddlewaresSpider(中间件)

可以自定义requests请求和进行response过滤

一般不用手写

################ 请求和数据流向

调度器 ==> 获取request对象(遍历spider通过yield产生的Request对象) ===> 引擎 ===> 下载中间件 ==> 下载器

下载器发送请求，获取响应 ==> 下载中间件 ==> 引擎 ==> 爬虫中间件 ==> 爬虫(交给设定的callback或默认初始请求对应的parse方法)

爬虫 提取数据 ==> 交给引擎(遍历spider通过yield产生的dict、item对象) ==> 管道

爬虫 url 组成发request对象 ==> 爬虫中间件 ==> 引擎 ==> 调度器

################ Scrapy创建项目

1.创建一个项目

scrapy startproject mySpider

2.生成一个爬虫

scrapy genspider tieba "tieba.baidu.com"

3.提取数据，创建新请求，构建数据

完善spider，使用xpath等方法

4.保存数据

pipeline中保存数据

########################################## Scrapy 具体使用

项目结构

├── justspider

│   ├── __init__.py

│   ├── items.py

│   ├── middlewares.py

│   ├── pipelines.py

│   ├── settings.py

│   └── spiders

│   ├── __init__.py

│   └── tieba.py

└── scrapy.cfg

############ settings文件分析

BOT_NAME = 'justspider'

SPIDER_MODULES = ['justspider.spiders']

NEWSPIDER_MODULE = 'justspider.spiders'

### 其他主要配置

1.User-Agent

#USER_AGENT = 'justspider (+http://www.yourdomain.com)'

2.是否遵守robots协议

ROBOTSTXT_OBEY = True

3.最大并发数

#CONCURRENT_REQUESTS = 32 默认是16

4.自动限流配置 autothrottle, 下载延迟

DOWNLOAD_DELAY = 3

5.是否使用cookie 默认是enable

#COOKIES_ENABLED = False

6.是否使用telnet控制台 默认是enable

#TELNETCONSOLE_ENABLED = False

7.重写默认的请求headers

#DEFAULT_REQUEST_HEADERS = {

# 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',

# 'Accept-Language': 'en',

#}

8.配置默认的爬虫中间件

#SPIDER_MIDDLEWARES = {

# 'justspider.middlewares.JustspiderSpiderMiddleware': 543,

#}

9.配置默认的下载中间件

#DOWNLOADER_MIDDLEWARES = {

# 'justspider.middlewares.JustspiderDownloaderMiddleware': 543,

#}

10.是否使用扩展

#EXTENSIONS = {

# 'scrapy.extensions.telnet.TelnetConsole': None,

#}

11.配置item使用的pipeline

#ITEM_PIPELINES = {

# 'justspider.pipelines.JustspiderPipeline': 300,

#}

12.自动限流的扩展，默认不使用

① 打开扩展

#AUTOTHROTTLE_ENABLED = True

②初始下载延迟

#AUTOTHROTTLE_START_DELAY = 5

③最大的下载延迟

#AUTOTHROTTLE_MAX_DELAY = 60

④平均并行请求数

#AUTOTHROTTLE_TARGET_CONCURRENCY = 1.0

⑤是否为每个接收到的响应显示流量状态

#AUTOTHROTTLE_DEBUG = False

13.打开、配置HTTP缓存(默认禁用)

①是否打开配置

#HTTPCACHE_ENABLED = True

②缓存过期的时长 秒为单位

#HTTPCACHE_EXPIRATION_SECS = 0

③ 缓存的目录

#HTTPCACHE_DIR = 'httpcache'

④对哪些状态码的请求不缓存

#HTTPCACHE_IGNORE_HTTP_CODES = []

⑤实现缓存存储后端的类

#HTTPCACHE_STORAGE = 'scrapy.extensions.httpcache.FilesystemCacheStorage'

######################## Spider重写,控制数据提取和继续请求的流程

启动爬虫

start_url地址的响应===>交给parse函数传入response===>parse函数提取数据

--------提取方法

response的选择器(response是一个scrapy.http.response.html.HtmlResponse对象)

①response.xpath()、②response.css()、③response.selector.re()

--------拿到数据列表之后再次提取

extract()提取数据，结果是列表，没有是空列表

extract_first()提取结果中第一个字符串，没有就是None

可以对获取的对象继续使用xpath，css和re

--------继续操作

情况一：需要构造新的请求(下一页，详情页等)，指定callback，以及为response设置的meta

yield scrapy.Request(item['detail_url'],

callback=self.parse_detail,

meta={'item': item})

# dont_filter：默认False，url会被去重;设置为True，可以在当前爬虫中对相同url请求多次

所有的callback和初始parse方法只有一个response参数，meta会作为response的属性传递

情况二：产生数据，这个数据会通过引擎交给pipeline

产生的数据可以是Item(scrapy.Item子类)、dict类型，具体代码为：

item = XXItem()

item.name = xx

yield item

其中XXItem类的实现为Item:

class SuningItem(scrapy.Item):

name = scrapy.Field()

-------scrapy.Spider类一些其他注意点

-----1

方法start_requests的默认实现为

def start_requests(self):

###......

for url in self.start_urls:

yield Request(url, dont_filter=True)

会遍历spider的start_urls这个list，并以此构建Request对象开始爬虫。

有一些场景需要重写这个方法，比如在爬虫开始直接导入用户登录的cookie，

这个时候不要忘记yield一个初始Request，否则爬虫无法开始。(Renren登录)

-----2

allowed_domains要添加可能爬取的所有url的domain，否则将无法爬取

######################## pipeline重写，数据持久化或者消费处理

可以不重写，那么产生的数据不会进行任何处理

通常重写以下几个方法：

1.open_spider(self, spider) 爬虫开始的时候执行一次

2.close_spider(self, spider) 爬虫结束的时候执行一次

可以在open_spdier中建立和数据库的连接，在close_spide关闭和数据库的连接

3.from_crawler(cls, crawler)

如果重写了，这个类方法会在Crawler中创建pipeline实例的时候调用。它必须返回一个新的pipeline实例。

Crawler对象提供了对所有Scrapy核心组件的访问权限，如settings何signals，

对pipeline来说，这个方法是访问和hook Scrapy基础设施的手段。

4.process_item(self, item, spider)

每个item pipeline组件都需要调用该方法，这个方法必须返回一个具有数据的dict，

或是 Item (或任何继承类)对象， 或是抛出 DropItem 异常，被丢弃的item将不会被之后的pipeline组件所处理。

---例子：

import pymongo

class MongoPipeline(object):

collection_name = 'scrapy_items'

def __init__(self, mongo_uri, mongo_db):

self.mongo_uri = mongo_uri

self.mongo_db = mongo_db

@classmethod

def from_crawler(cls, crawler):

return cls(

mongo_uri=crawler.settings.get('MONGO_URI'),

mongo_db=crawler.settings.get('MONGO_DATABASE', 'items')

)

def open_spider(self, spider):

self.client = pymongo.MongoClient(self.mongo_uri)

self.db = self.client[self.mongo_db]

def close_spider(self, spider):

self.client.close()

def process_item(self, item, spider):

self.db[self.collection_name].insert(dict(item))

return item

--------------另外，可以在数据入库之前添加去重的pipeline

from scrapy.exceptions import DropItem

class DuplicatesPipeline(object):

def __init__(self):

self.ids_seen = set()

def process_item(self, item, spider):

if item['id'] in self.ids_seen:

raise DropItem("Duplicate item found: %s" % item)

else:

self.ids_seen.add(item['id'])

return item

----只需要在settings设置去重pipeline的权重小于入库pipeline即可。

######################## 中间件 及 配置

############### 下载中间件

如果您想禁止内置的(在 DOWNLOADER_MIDDLEWARES_BASE 中设置并默认启用的)中间件，

您必须在项目的 DOWNLOADER_MIDDLEWARES 设置中定义该中间件，并将其值赋为 None 。

例如，如果您想要关闭user-agent中间件:

DOWNLOADER_MIDDLEWARES = {

'myproject.middlewares.CustomDownloaderMiddleware': 543,

'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,

}

##### 经常重写的下载中间件方法

1.process_request(request, spider) 处理请求

返回 None 、返回一个 Response 对象、返回一个 Request 对象或raise IgnoreRequest

2.process_response(request, response, spider)

返回一个 Response 对象、 返回一个 Request 对象或raise一个 IgnoreRequest 异常。

3.process_exception(request, exception, spider)

当下载处理器(download handler)或 process_request() (下载中间件)抛出异常(包括 IgnoreRequest 异常)时， Scrapy调用 process_exception() 。

process_exception() 应该返回以下之一: 返回 None 、 一个 Response 对象、或者一个 Request 对象。

如果其返回 None，Scrapy将会继续处理该异常，接着调用已安装的其他中间件的 process_exception() 方法，直到所有中间件都被调用完毕，则调用默认的异常处理。

如果其返回一个 Response 对象，则已安装的中间件链的 process_response() 方法被调用。Scrapy将不会调用任何其他中间件的 process_exception() 方法。

如果其返回一个 Request 对象， 则返回的request将会被重新调用下载。这将停止中间件的 process_exception() 方法执行，就如返回一个response的那样

----- 常用的内置下载中间件

CookiesMiddleware 默认使用，可以通过settings的COOKIES_ENABLED设置是否禁用

DefaultHeadersMiddleware 指定request的header

DownloadTimeoutMiddleware 依据settings中的DOWNLOAD_TIMEOUT设置超时

HttpAuthMiddleware 该中间件完成某些使用 Basic access authentication (或者叫HTTP认证)的spider生成的请求的认证过程，

HttpCacheMiddleware 该中间件为所有HTTP request及response提供了底层(low-level)缓存支持。 其由cache存储后端及cache策略组成。

HttpCompressionMiddleware 压缩支持 通过settings中的设置COMPRESSION_ENABLED，默认True

HttpProxyMiddleware 代理支持，通过创建Request时传递代理ip+port

RedirectMiddleware 该中间件根据response的状态处理重定向的request。

MetaRefreshMiddleware 该中间件根据meta-refresh html标签处理request重定向。

RetryMiddleware 该中间件将重试可能由于临时的问题，例如连接超时或者HTTP 500错误导致失败的页面 settings:RETRY_TIMES RETRY_HTTP_CODES

RobotsTxtMiddleware 该中间件过滤所有robots.txt eclusion standard中禁止的request。settings: ROBOTSTXT_OBEY

UserAgentMiddleware 用于**覆盖**spider的默认user agent的中间件。

AjaxCrawlMiddleware 根据meta-fragment html标签查找 ‘AJAX可爬取’ 页面的中间件

############### Spider中间件

---- 经常重写的Spider中间件

1.process_spider_input(response, spider)

当response通过spider中间件时，该方法被调用，处理该response。

process_spider_input() 应该返回 None 或者抛出一个异常。

2.process_spider_output(response, result, spider)

当Spider处理response返回result时，该方法被调用。

process_spider_output() 必须返回包含 Request 、dict 或 Item 对象的可迭代对象

3.process_spider_exception(response, exception, spider)

当spider或(其他spider中间件的) process_spider_input() 跑出异常时， 该方法被调用。

4.process_start_requests(start_requests, spider)

该方法以spider 启动的request为参数被调用，执行的过程类似于 process_spider_output() ，

只不过其没有相关联的response并且必须返回request(不是item)。

---- 常用的内置Spider中间件

1.DepthMiddleware DepthMiddleware是一个用于追踪每个Request在被爬取的网站的深度的中间件。

其可以用来限制爬取深度的最大深度或类似的事情。 settings:DEPTH_LIMIT

2.HttpErrorMiddleware

过滤出所有失败(错误)的HTTP response，因此spider不需要处理这些request。

处理这些request意味着消耗更多资源，并且使得spider逻辑更为复杂。

3.OffsiteMiddleware

过滤出所有URL不由该spider负责的Request。

该中间件过滤出所有主机名不在spider属性 allowed_domains 的request。

4.RefererMiddleware

根据生成Request的Response的URL来设置Request Referer 字段。

5.UrlLengthMiddleware

过滤出URL长度比URLLENGTH_LIMIT的request。

#################### Scrapy处理表单请求，如何构造Request用于提交表单(GitHub为例)

1.带上cookie直接请求

1.构造cookie字典

2.添加到scrapy.Request(cookies=cookies)

3.cookie字符串不能够放到headers，没有效果

2.scrapy.FormReuquest

代码：scrapy.FormReuquest（url,formdata,callback）

其中url是要post提交的url地址，formdata，请求体

3.scrapy.FormReuquest.from_response(response,formdata,callback)

根据当前页面的response自动选取表单，formdata只需填入Web页面要填写的字段即可。

注意：如果有多个表单，可以使用formxpath或formcss这两个参数选取

###################### CrawlSpider

1.创建的命令

scrapy genspider -t crawl spdier_name allow_domain

2.生成的CrawSpider类继承自Spider，增加类属性rules，是一个Rule类型的元组，parse方法变为parse_item

特点：

1.根据Rule元组定义的规则寻找url，构建请求，如此反复，通过最终的callback做数据提取

2.callback依然可以yield新的Request，继续使用Rule元组继续筛选url，

缺点：crawlspider的解析函数中间不能传递数据，经常在详情页能够获取全部数据的时候使用crawlspider,

parse_item就是为解析最终拿数据的页面准备的

3.Rule构建，有几个重要的参数：

①link_extractor链接提取器

LinkExtractor(allow=r'/p/\d{10}') # restrict_xpaths、restrict_css都是元组类型

②callback，回调函数，可用于yield Request或Item

③follow，根据当前提取规则得到response之后，是否继续使用rules下的Rule继续提取

###################### logger

scrapy中使用日志：

settings：LOG_FILE = "./log.log" # 日志存储的位置,终端不会再展示日志

scrapy中使用日志输出信息：

方式①：

1.import logging

2. logger = logging.getLogger(__name__)

# __name__ 用于format,通常显示为提示[__name__]

能够显示当前的输出来自于那个文件

3.logger.warning("....")

方式②：

如果当前类是Spider，直接使用

self.logger.warning('....')

可以在settings里面通过LOG_LEVEL设置日志级别，还可以配置其他设置：

LOG_FILE、LOG_ENABLED、LOG_ENCODING、LOG_FORMAT、LOG_DATEFORMAT、LOG_STDOUT

########### 一般项目使用系统的logging模块

1.import logging

2.logging.BasicConfig({})

配置日志数据的样式

3.实例化logger = logging.getLogger(__name__)

4.导入logger，使用logger.info("") <=> logging.log(logging.INFO, "")

################################# Scrapy Shell

怎么使用

scrapy shell url

能干什么

观察scarpy中各种对象的方法和属性

response.text 网页的html字符串str

response.body 获取网页的响应的bytes

resposne.request.url

resposne.url

response.request.url

测试xpath

############ Scrapy部署

############ telnet终端

############ feed export

########################################## Scrapy-Redis

scarpy_redis是一个基于redis的scarpy的组件

主要作用：

1.持久化`待爬取`的request对象，经过序列化存入redis中，可以实现暂停、断点续爬、分布式爬虫

2.已经看到过的request的指纹存入redis，作为去重的依据

工作流程：

1.调度器的带爬取的request对象，已经看到过的request的指纹保存在redis中

2.itempipeline的数据默认保存在redis中

和scrapy的区别：

settings多了5行

1.指定了调度器的类

2.指定了去重的类

3.指定了redis_url

DUPEFILTER_CLASS = 'scrapy_redis.dupefilter.RFPDupeFilter'

SCHEDULER = 'scrapy_redis.scheduler.Scheduler'

SCHEDULER_PERSIST = True

REDIS_URL = 'redis://192.168.199.131:6379/5'

ITEM_PIPELINES = {

'book.pipelines.BookPipeline': 300,

'scrapy_redis.pipelines.RedisPipeline': 400,

}

###### scrapy_reids如何实现--概述

1.去重

1.hashlib.sha1()

2.加密了request对象的请求方法，请求体，url

3.生成16进制字符串作为当前request的指纹

4.把指纹存在redis的集合中，后续的request的指纹判断是否存在该集合中

2.待爬取的request对象入队

1.url在start_urls中的时候

2.url地址之前没有见过的时候

3.dont_fileter=Ture,表示不过滤，会入队

################################# 源码分析

---------------计算指纹的方法：

from scrapy.utils.request import request_fingerprint

这个函数默认会忽略cookie和其他header，如果想让一些header参与指纹计算

使用include_headers参数，它是要包含的请求头列表。

最终参数与计算hash的值按顺序为：

请求method，url，body，include_header和对应的value，使用的是sha1算法

----------------指纹过滤器

RFPDupeFilter (Request Fingerprint duplicates filter) 请求指纹重复过滤器

### scrapy默认的指纹去重过滤器

scrapy.dupefilters.RFPDupeFilter 继承自BaseDupeFilter

1.对象属性fingerprints是set()类型，用于在内存中存储，已经访问过的request指纹

2.如果对象实例化时传入了path参数，那么会在path路径下的生成requests.seen用于持久化存储，只需在settings

指定DUPEFILTER_DEBUG即可，那么会使用下面这个类方法实例化这个类

def from_settings(cls, settings):

debug = settings.getbool('DUPEFILTER_DEBUG')

return cls(job_dir(settings), debug)

# job_dir 实现为

def job_dir(settings):

path = settings['JOBDIR']

if path and not os.path.exists(path):

os.makedirs(path)

return path

可知：requests.seen 最终依赖于settings中JOBDIR这个配置,存储在JOBDIR指定的目录下

3.是否已经爬取过的判断：

def request_seen(self, request):

fp = self.request_fingerprint(request)

if fp in self.fingerprints:

return True

self.fingerprints.add(fp)

if self.file:

self.file.write(fp + os.linesep)

可知：直接返回内存缓存fingerprints这个set里面是否有请求的指纹

### scrapy-redis实现的指纹去重过滤器

scrapy_redis.dupefilter.RFPDupeFilter 继承自scrapy默认的BaseDupeFilter

1.key属性:用于存储redis存储该次请求的指纹的key，

dupefilter:%(timestamp)s % {'timestamp': int(time.time())}

server属性：对redis的链接

2.from_settings实例化对象

def from_settings(cls, settings):

server = get_redis_from_settings(settings)

key = defaults.DUPEFILTER_KEY % {'timestamp': int(time.time())}

debug = settings.getbool('DUPEFILTER_DEBUG')

return cls(server, key=key, debug=debug)

可知：通过settings的配置创建redis连接

3.是否已经爬取过的判断：

def request_seen(self, request):

fp = self.request_fingerprint(request)

added = self.server.sadd(self.key, fp)

return added == 0

向redis插入指纹失败，则已经爬取过

----------------将要爬取的request放到队列中

----scrapy默认入队实现 scrapy.core.scheduler.Scheduler

def enqueue_request(self, request):

if not request.dont_filter and self.df.request_seen(request):

self.df.log(request, self.spider)

return False

dqok = self._dqpush(request)

if dqok:

self.stats.inc_value('scheduler/enqueued/disk', spider=self.spider)

else:

self._mqpush(request)

self.stats.inc_value('scheduler/enqueued/memory', spider=self.spider)

self.stats.inc_value('scheduler/enqueued', spider=self.spider)

return True

----scrapy-redis入队实现 scrapy_redis.scheduler.Scheduler

def enqueue_request(self, request):

if not request.dont_filter and self.df.request_seen(request):

self.df.log(request, self.spider)

return False

if self.stats:

self.stats.inc_value('scheduler/enqueued/redis', spider=self.spider)

self.queue.push(request)

return True

思路完全一致：

如果 request.dont_filter为True，或者，指纹过滤器验证没有重复，直接入队列

########################################## 其他知识点

代理IP的类型：（透明、匿名、高匿）

①透明代理的意思是客户端根本不需要知道有代理服务器的存在，但是它传送的仍然是真实的IP。你要想隐藏的话，不要用这个。

②普通匿名代理能隐藏客户机的真实IP，但会改变我们的请求信息，服务器端有可能会认为我们使用了代理。

不过使用此种代理时，虽然被访问的网站不能知道你的ip地址，但仍然可以知道你在使用代理，当然某些能够侦测ip的网页仍然可以查到你的ip。

③高匿名代理不改变客户机的请求，这样在服务器看来就像有个真正的客户浏览器在访问它，这时客户的真实IP是隐藏的，服务器端不会认为我们使用了代理。

一些其他情况的反反爬：http://www.shenjianshou.cn/blog/?p=292