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="112358", 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,
......
}