高用代理 | Joynice

由于我们的代理有限，所以需要去一些代理网站上爬取一些可用的高效的代理，所以就需要爬虫去完成这部分的工作。

爬虫部分
代理检测
存储

爬虫部分

　　由于我们的代理有限，所以需要去一些代理网站上爬取一些可用的高效的代理，所以就需要爬虫去完成这部分的工作。

　　为了爬取高效的代理，找到以下的代理网站进行爬取：

http://ip.kxdaili.com/
http://www.xicidaili.com/
http://www.66ip.cn/
http://www.66ip.cn/areaindex_%s/1.html
http://www.89ip.cn/

　　首先，定义个爬虫类，我们只需传入爬取网站的url、正则表达式、以及标志符flag就可以调用get_data（）函数进行爬取，大大优化了代码结构，代码如下：

class Crawler(object):
    def __init__(self, url, regular, flag=None):
        self.url = url
        self.regular = regular
        self.flag = flag

    def get_data(self):
        proxies_list = []
        for i in self.url:
            print(i)
            try:
                text = requests.get(i, headers=config.HEADERS)
            except:
                pass
            time.sleep(5)
            text.encoding = 'utf-8'
            data = re.findall(self.regular, text.text)
            if i[11:15] == '66ip':
                for t in range(1, int(len(data) / self.flag)):
                    proxies = '{}:{}'.format(data[self.flag * t], data[(self.flag * t) + 1])
                    proxies_list.append(proxies)
            elif i[11:15] == '89ip':
                proxies_list = data[1:]
            else:
                for t in range(0, int(len(data) / self.flag)):
                    proxies = '{}:{}'.format(data[self.flag * t], data[(self.flag * t) + 1])
                    proxies_list.append(proxies)
        return proxies_list

　　代理列表如下：

SPIDER_PARSER_LIST =[
{    # 开心代理
    'url':['http://ip.kxdaili.com/ipList/%s.html#ip' % i for i in range(1, 11)],
    'regular':'<td>(.*?)</td>',
    'flag':7
},
{    # 西刺代理
    'url':['http://www.xicidaili.com/nn/%s' % i for i in range(1, 5)],
    'regular':'<td>(.*?)</td>',
    'flag':5
},
{    # 66ip代理-全国代理
    'url': ['http://www.66ip.cn/%s.html' % i for i in range(1, 40)],
    'regular': '<td>(.*?)</td>',
    'flag':5
},
{    # 66ip代理-各省代理
    'url': ['http://www.66ip.cn/areaindex_%s/1.html' % i for i in range(1, 35)],
    'regular': '<td>(.*?)</td>',
    'flag':5
},
{    # 根据api获得代理
    'url': ['http://www.89ip.cn/tqdl.html?api=1&num={}&port=&address=&isp='.format(500)],
    'regular': '(.*?)<br>',
    'flag': None
},
]

　　调用方法如下：　　

def get_object():
    proxise_list = []
    for pirder_paeser in config.SPIDER_PARSER_LIST:
        url = Crawler(url=pirder_paeser.get('url'), regular=pirder_paeser.get('regular'),
                      flag=pirder_paeser.get('flag')).get_data()
        proxise_list.append(url)
    return proxise_list

代理检测

　　将存在列表里的代理组成一个新的列表，利用进程池进行快速地检测，检测主要如下：

代理是否可用，代理延迟大于3秒即视为不可用。
http与https代理划分。
高匿性检测（此部分完成的不好）。

　　由于自己的知识的欠缺，对于代理方面的知识了解不够全面，导致对于代理检测也是跟着自己的想法进行测试，不知道是否合理，请大家指出。代码如下：

def check(proxy):
    http_proxy_list = []
    http_proxy_gaoni_list = []
    https_proxy_list = []

    proxy_http_dict = {
        'http': proxy
    }
    proxy_https_dict = {
        'https': proxy
    }
    try:
        http_res = requests.get(config.SPIDER_PUBLIC_URL, proxies=proxy_http_dict, timeout=5,
                                headers=config.HEADERS)
        time.sleep(1)
        if http_res.status_code == 200:
            try:
                dic1 = eval(http_res.text)
                ip = dic1.get('remote_addr')
                if ip == public_network_ip:
                    http_proxy_list.append(proxy)
                    print(http_res.text)
                else:
                    print(http_res.text)
                    http_proxy_gaoni_list.append(proxy)
            except:
                pass
    except Exception as e:
        print(e)
    try:
        https_res = requests.get('https://www.baidu.com/', timeout=5, proxies=proxy_https_dict
                                 , headers=config.HEADERS, verify=False)
        time.sleep(1)
        if https_res.status_code == 200:
            print('https:')
            https_proxy_list.append(proxy)
    except Exception as e:
        print(e)
    print(http_proxy_list, http_proxy_gaoni_list, https_proxy_list)
    return http_proxy_list, http_proxy_gaoni_list, https_proxy_list

存储

　　利用python的flask-sqlalchemy模块进行关系到表的映射。Proxy结构如下：

class Proxy(db.Model):
    __tablename__ = 'proxy_pool'
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    proxy = db.Column(db.String(100), nullable=False,unique=False)
    http = db.Column(db.String(100), nullable=False)
    type = db.Column(db.String(100), nullable=False)
    score = db.Column(db.Integer, nullable=False)
    add_time = db.Column(db.DateTime, nullable=False)
    check_time = db.Column(db.DateTime, nullable=False)
    res_time = db.Column(db.Float, nullable=False)

　　存储是利用非orm结构进行存储，将检测的结果一次性存储，缩短了存储时间，减小了对数据库的压力。代码如下：

def save(proxy_list1, proxy_list2, proxy_list3):

    if len(proxy_list1) > 0:
        session.execute(Proxy.__table__.insert(), [{'proxy': str(i), 'http': 'http', 'type': '透明', 'score': str(100)
                                                       , 'add_time': datetime.datetime.now(),
                                                    'check_time': datetime.datetime.now()
                                                       , 'res_time': 0.1} for i in proxy_list1])
    else:
        pass
    if len(proxy_list2) > 0:
        session.execute(Proxy.__table__.insert(), [
            {'proxy': str(i), 'http': 'https', 'type': '高匿', 'score': str(100), 'add_time': datetime.datetime.now(),
             'check_time': datetime.datetime.now(), 'res_time': 0.1} for i in proxy_list2])
    else:
        pass
    if len(proxy_list3) > 0:
        session.execute(Proxy.__table__.insert(), [
            {'proxy': str(i), 'http': 'http', 'type': '高匿', 'score': str(100), 'add_time': datetime.datetime.now(),
             'check_time': datetime.datetime.now(), 'res_time': 0.1} for i in proxy_list3])
    else:
        pass
    session.commit()
    session.close()

总结

　　第一次，合作完成项目，学习到了许多知识如：

利用类，充分利用代码，降低耦合度。
利用进程池缩短检测时间。
以及非orm存储数据库。