scrapy几种反反爬策略

一.浏览器代理

　　1.直接处理：

　　　　1.1在setting中配置浏览器的各类代理：

user_agent_list=[

"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36",
......
]

　　　　1.2然后在各个请求中调用：

import random
from setting import user_agent_list
headers=
{
"Host":"",
......
"User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36",
}
def parse(self,response):
    ......

    user_agent=random.choice(user_agent_list)
    self.header["User-Agent"]=user_agent
    yeild scrapy.Request(request_url,headers=self.headers,callback=...)

　　　　1.3缺点：

　　　　　　使用麻烦，各个请求都要调用，而且耦合性高。 　　

　　2.使用downloader-middlewares：

　　　　2.1使用downloader-middleware(setting中默认是注销了的)：

　　

　　　　2.2useragent源码如下（默认的User-Agent为Scraoy，可以直接在setting中配置USER_AGENT="......"就会替换Scrapy如红框中）:

　　　　2.3自定义useragentmiddleware（需要在setting中将默认的middleware致为none或数字比自定以的小）：

官网简介

　　　　　　　　2.3.1直接重写函数：

#这样能实现，写一个random（）函数选择代理，但维护user_agent_list很麻烦，需要重启spider
class RandomUserAgentMiddleware(object):
    #随机选择User-Agent
    def __init__(self,crawler):
        super(RandomUserAgentMiddleware,self).__init__()
        self.user_agent_list=crawler.setting.get("user_agent_list","")
    @classmethod
    def from_crawler(cls,crawler):
        return cls(crawler)
    def process_request(self,request,spider):
        request.headers.setdefault('User-Agent',random())

　　　　　　　2.3.2fake_useragent的使用：　　

　　　　　　　　安装：pip install fake_useragent　　

　　　　　　　　使用：

from fake_useragent import UserAgent
......
class RandomUserAgentMiddleware(object):
    #随机选择User-Agent，所有浏览器
    def __init__(self,crawler):
        super(RandomUserAgentMiddleware,self).__init__()
        self.ua = UserAgent()
    @classmethod
    def from_crawler(cls,crawler):
        return cls(crawler)
    def process_request(self,request,spider):
        request.headers.setdefault('User-Agent',self.ua.random)

　　　

class RandomUserAgentMiddleware(object):
    # 随机选择User-Agent
    def __init__(self, crawler):
        super(RandomUserAgentMiddleware, self).__init__()
        self.ua = UserAgent()
        #RANDOM_UA_TYPE为setting中配置的浏览器类型
        self.ua_type = crawler.settings.get("RANDOM_UA_TYPE", "random")

    @classmethod
    def from_crawler(cls, crawler):
        return cls(crawler)

    def process_request(self, request, spider):
        #函数里定义函数（动态语言闭包特性），获取是哪种浏览器类型的随机
        def get_ua():
            #相当于取self.ua.ua_type
            return getattr(self.ua, self.ua_type)

        request.headers.setdefault('User-Agent', get_ua())

　　　　　　2.3.3自定义中间件配置：

二.IP代理设置

　　1.重启路由器：

　　　　IP在绝大多数情况会变，用本机IP比用代理IP爬取速度更快。

　　2.代理IP原理：

　　　　1.本机向代理服务器发起请求访问某个网站——>

　　　　2.代理服务器访问请求的网站——>

　　　　3.数据返回给代理服务器——>

　　　　4.代理服务器把数据返回给本机。

　　3.免费ip网站获取ip（西刺网【设置一定间隔】）：

 # _*_ encoding:utf-8 _*_
 __author__ = 'LYQ'
 __date__ = '2018/10/6 17:16'
 import requests
 from scrapy.selector import Selector
 import MySQLdb

 conn = MySQLdb.Connect(host="localhost", user="root", passwd="", db="xici", charset="utf8")
 cursor = conn.cursor()

 def crawl_ips():
     headers = {
         "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36"
     }
     for i in range(1, 3460):
         re = requests.get("http://www.xicidaili.com/nn/{0}".format(i), headers=headers)
         selector = Selector(text=re.text)
         ip_lists = selector.css('#ip_list tr')
         get_ips = []
         for ip_list in ip_lists[1:]:
             speed = ip_list.css(".bar::attr(title)").extract_first()
             if speed:
                 speed = float(speed.split('秒')[0])
             texts = ip_list.css("td::text").extract()
             ip = texts[0]
             port = texts[1]
             proxy_type = ip_list.xpath("td[6]/text()").extract_first()
             get_ips.append((ip, port, proxy_type, speed))
         for ip_info in get_ips:
             cursor.execute(
                 "INSERT  REPLACE INTO proxy_ips(ip,port,type,speed) VALUES('{0}','{1}','{2}','{3}')".format(ip_info[0],
                                                                                                             ip_info[1],
                                                                                                             ip_info[2],
                                                                                                             ip_info[3])
             )
             conn.commit()

 class Get_ip(object):
     def judge_ip(self, ip, port):
         # 判断ip是否可用
         http_url = 'https://www.baidu.com'
         proxy_url = 'https://{0}:{1}'.format(ip, port)
         try:
             proxy_dict = {
                 'http': proxy_url
             }
             response = requests.get(http_url, proxies=proxy_dict)
         except:
             print("该ip：{0}不可用".format(ip))
             self.delete_ip(ip)
             return False
         else:
             code = response.status_code
             if code >= 200 and code < 300:
                 print("ip:{0}有效".format(ip))
                 return True
             else:
                 print("该ip：{0}不可用".format(ip))
                 self.delete_ip(ip)
                 return False

     def delete_ip(self, ip):
         delete_sql = """
         delete from proxy_ips where ip='{0}'
         """.format(ip)
         cursor.execute(delete_sql)
         conn.commit()
         return True

     def get_random_ip(self):
         random_sql = """
         SELECT ip,port from proxy_ips ORDER BY RAND() LIMIT 1
         """
         result = cursor.execute(random_sql)
         for ip_info in cursor.fetchall():
             ip = ip_info[0]
             port = ip_info[1]
             judge_re=self.judge_ip(ip, port)
             if judge_re:
                 return 'http://{0}:{1}'.format(ip,port)
             else:
                 return self.get_random_ip()

 if __name__=='__main__':
     # crawl_ips()
     get_ip = Get_ip()
     a = get_ip.get_random_ip()

　　4.ip代理中间件书写：

class RandomProxyMiddleware(object):
    #动态代理ip的使用
    def process_request(self, request, spider):
        get_ip=Get_ip()
        request.meta['proxy']=get_ip.get_random_ip()

　　5.开源库的使用（scrapy_proxy处理ip）：

　　　　　　scrapy-crawla,haipproxy,scrapy-proxies等，可以在github上查看

　　6.Tor（洋葱网络的使用），可以隐藏ip（需要vpn）

三.验证码的识别

　　1.编码实现（tesseract-ocr）：

　　　　需要数据训练，识别率低。

　　2.在线打码（识别率在90%以上）：

　　　　2.1云打码平台的使用：

注册之后（开发者和用户模式），可以下载对应的调用实列查看

软件添加

验证码类型

错误状态码，可以在官网查看所有

　　　　2.2识别接口：

 import json
 import requests

 class YDMHttp(object):
     apiurl = 'http://api.yundama.com/api.php'
     username = ''
     password = ''
     appid = ''
     appkey = ''

     def __init__(self, username, password, appid, appkey):
         self.username = username
         self.password = password
         self.appid = str(appid)
         self.appkey = appkey

     def balance(self):
         data = {'method': 'balance', 'username': self.username, 'password': self.password, 'appid': self.appid, 'appkey': self.appkey}
         response_data = requests.post(self.apiurl, data=data)
         ret_data = json.loads(response_data.text)
         if ret_data["ret"] == 0:
             print ("获取剩余积分", ret_data["balance"])
             return ret_data["balance"]
         else:
             return None

     def login(self):
         data = {'method': 'login', 'username': self.username, 'password': self.password, 'appid': self.appid, 'appkey': self.appkey}
         response_data = requests.post(self.apiurl, data=data)
         ret_data = json.loads(response_data.text)
         if ret_data["ret"] == 0:
             print ("登录成功", ret_data["uid"])
             return ret_data["uid"]
         else:
             return None

     def decode(self, filename, codetype, timeout):
         data = {'method': 'upload', 'username': self.username, 'password': self.password, 'appid': self.appid, 'appkey': self.appkey, 'codetype': str(codetype), 'timeout': str(timeout)}
         files = {'file': open(filename, 'rb')}
         response_data = requests.post(self.apiurl, files=files, data=data)
         ret_data = json.loads(response_data.text)
         if ret_data["ret"] == 0:
             print ("识别成功", ret_data["text"])
             return ret_data["text"]
         else:
             return None

 if __name__ == "__main__":
     # 用户名
     username = ''
     # 密码
     password = ''
     # 软件ＩＤ，开发者分成必要参数。登录开发者后台【我的软件】获得！
     appid = 5921
     # 软件密钥，开发者分成必要参数。登录开发者后台【我的软件】获得！
     appkey = '4b29b3e33db637975d5e51bdf9f2c03b'
     # 图片文件
     filename = 'getimage.jpg'
     # 验证码类型，# 例：1004表示4位字母数字，不同类型收费不同。请准确填写，否则影响识别率。在此查询所有类型 http://www.yundama.com/price.html
     codetype = 1004
     # 超时时间，秒
     timeout = 60
     # 检查
     if (username == 'username'):
         print ('请设置好相关参数再测试')
     else:
         # 初始化
         yundama = YDMHttp(username, password, appid, appkey)

         # 登陆云打码
         uid = yundama.login()
         print ('uid: %s' % uid)

         # 查询余额
         balance = yundama.balance()
         print ('balance: %s' % balance)

         # 开始识别，图片路径，验证码类型ID，超时时间（秒），识别结果
         text = yundama.decode(filename, codetype, timeout)

结果如下

　　3.人工打码：

　　　　识别率最高，费用高。

四.配置使爬虫被识别率降低

　　1.cookie的禁用：

　　　　1.1setting.py中（不需登录的网站）：

COOKIES_ENABLED = False　　

　　　　1.2自动限速(AutoThrottle)扩展：

　　　　　　主要配置（setting中）：

　　　　　　　　AUTOTHROTTLE_ENABLED  默认: False  启用AutoThrottle扩展。

　　　　　　　　AUTOTHROTTLE_START_DELAY  默认: 5.0  初始下载延迟(单位:秒)。

　　　　　　　　AUTOTHROTTLE_MAX_DELAY  默认: 60.0  在高延迟情况下最大的下载延迟(单位秒)。

　　　　　　　　AUTOTHROTTLE_DEBUG  默认: False  起用AutoThrottle调试(debug)模式，展示每个接收到的response。 您可以通过此来查看限速参数是如何实时被调整的。

　　　　1.3不同的spider设置不同的setting：

　　　　　　在spider中设置（这里的属性会覆盖setting中的）：

custom_setting={
"COOKIES_ENABLED":True,
......
}