python爬虫--代理的使用

代理池的维护

基本模块：

• 存储模块： 使用Redis的有序集合负责存储抓取下来的代理，保证代理不重复
• 获取模块：需要定时在各大代理网站抓取代理，代理的形式都是IP加端口，尽量从不同来源获取，尽量抓取高匿代理。
• 检测模块：需要定时检测数据库中的代理，设置一个检测链接，最好是爬取哪个网站就检测哪个网站
• 接口模块：需要用API来提供对外服务的接口，由于可用代理可能有多个，那么我们可以设置一个随机返回某个可用代理的接口，这样就能保证每个可用代理都可以取到实现负载均衡

代理池

存储模块：使用redis的有序集合，有序集合的每个元素都有一个分数字段，分数是可以重复的。根据分数对集合进行排序，可以作为判断一个代理是否可用的标志。

操作数据库的有序集合

MAX_SCORE=100
MIN_SCORE=0
INITIAL_SCORE=10
REDIS_HOST='localhost'
REDIS_PORT=6379
REDIS_PADDWORD=None
REDIS_KEY='proxies'
import redis
from random import choice

class RedisClient(object):
    def __init__(self,host=REDIS_HOST,port=REDIS_PORT,password=REDIS_PADDWORD):
        """
        初始化
        :param host:Redis 地址
        :param port: Redis 端口
        :param password: Redis 密码
        """

        self.db=redis.StrictRedis(host=host,port=port,password=password,decode_responses=True)
    def add(self,proxy,score=INITIAL_SCORE):
        """
        添加代理，设置分数为最高
        :param proxy: 代理
        :param score: 分数
        :return: 添加结果
        """
        if not self.db.zscore(REDIS_KEY,proxy):
            return self.db.zadd(REDIS_KEY,score,proxy)
    #随机获取代理
    def random(self):
        """
        随机获取有效代理，首先尝试获取最高分数代理，如果最高分数不存在，则按照排名获取，否则异常
        :return: 随即代理
        """
        result=self.db.zrangebyscore(REDIS_KEY,MAX_SCORE,MAX_SCORE)
        if len(result):
            return choice(result)
        else:
            result=self.db.zrevrange(REDIS_KEY,0,100)
            if len(result):
                return choice(result)
            else:
                raise PoolEmptyError
    #检测代理无效时分数减1
    def decrease(self,proxy):
        """
        代理值减一分，分数小于最小值，则代理删除
        :param proxy: 代理
        :return: 修改后的代理分数
        """
        score=self.db.zscore(REDIS_KEY,proxy)
        if score and score > MIN_SCORE:
            print('代理',proxy,'当前分数',score,'减1')
            return self.db.zincrby(REDIS_KEY,proxy,-1)
        else:
            print('代理',proxy,'当前分数',score,'移除')
            return self.db.zrem(REDIS_KEY,proxy)
    #判断代理是否在集合
    def exists(self,proxy):
        """
        判断是否存在
        :param proxy:代理
        :return: 是否存在
        """
        return not self.db.zscore(REDIS_KEY,proxy)==None
    #设置代理分数
    def max(self,proxy):
        """
        将代理设置为MAX_SCORE
        :param proxy: 代理
        :return: 设置结果
        """
        print('代理',proxy,'可用，设置为',MAX_SCORE)
        return self.db.zadd(REDIS_KEY,MAX_SCORE,proxy)
    #返回当前集合的元素个数
    def count(self):
        """
        获取数量
        :return:数量
        """
        return self.db.zcard(REDIS_KEY)
    #返回所有的代理列表
    def all(self):
        """
        获取全部代理
        :return: 全部代理列表
        """
        return self.db.zrangebyscore(REDIS_KEY,MIN_SCORE,MAX_SCORE)

获取模块

import json
from .utils import get_page
from pyquery import PyQuery as pq

class ProxyMetaclass(type):
    def __new__(cls, name,bases,attrs):
        count=0
        attrs['__CrawlFunc__']=[]
        # 判断方法开头是否是Crawl，如果是则将其加入到__CrawlFunc__属性中，就成功将所有以crawl开头的方法定义成了一个属性，动态获取到所有以crawl开头的方法列表
        for k,v in attrs.items():
            if 'crawl_'in K:
                attrs['__CrawlFunc__'].append(k)
                count+=1
        attrs['__CrawlFuncCount__']=count
        return type.__new__(cls,name,bases,attrs)

class Crawler(object,metaclass=ProxyMetaclass):
    def get_proxies(self,callback):
        proxies=[]
        for proxy in eval("self.{}()".format(callback)):
            print('成功获取到代理',proxy)
            proxies.append(proxy)
        return proxies
    def crawl_daili66(self,page_count=4):
        """
        获取代理66
        :param page_count:页码
        :return: 代理
        """
        start_url='http://www.66ip.cn/{}/html'
        urls=[start_url.format(page)for page in range(1,page_count+1)]
        for url in urls:
            print('Crawling',url)
            html=get_page(url)
            if html:
                doc=pq(html)
                trs=doc('.containerbox table tr:gt(0)').items()
                for tr in trs:
                    ip=tr.find('td:nth-child(1)').text()
                    port=tr.find('td:nth-child(2)').text()
                    yield ':'.join([ip,port])
    def crawl_proxy360(self):
        """
        获取Proxy360
        :return: 代理
        """
        start_url='http://www.proxy360.cn/Regio.China'
        print('Crawling',start_url)
        html=get_page(start_url)
        if html:
            doc=pq(html)
            lines=doc('div[name="list_proxy_ip"]').items()
            for line in lines:
                ip=line.find('.tbBottomLine:nth-child(1)').text()
                port=line.find('.tbBottomLine:nth-child(2)').text()
                yield ':'.join([ip,port])

    def crawl_goubanjia(self):
        """
        获取Goubanjia
        :return: 代理
        """
        start_url='http://www.goubanjia.com/free/gngn/index.shtml'
        html=get_page(start_url)
        if html:
            doc=pq(html)
            tds=doc('td.ip').items()
            for td in tds:
                td.find('p').remove()
                yield td.text().replace(' ','')
#定义一个Getter类，用来动态调用所有以crawl开头的方法
from db import RedisClient
from crawler import Crawler
POOL_UPPER_THRESHOLD=10000

class Getter():
    def __init__(self):
        self.redis=RedisClient()
        self.crawler=Crawler()
    def is_over_threshold(self):
        """
        判断你是否达到了代理池的限制
        :return:
        """
        if self.redis.count()>=POOL_UPPER_THRESHOLD:
            return True
        else:
            return False
    def run(self):
        print('获取器开始执行')
        if not self.is_over_threshold():
            for callback_label in range(self.crawler.__CrawFuncCount__):
                callback=self.crawler.CrawlFunc__[callback_label]
                proxies=self.crawler.get_proxies(callback)
                for proxy in proxies:
                    self.redis.add(proxy)

检测模块

VALID_STATUS_CODES=[200]
TEST_URL='http://www.baidu.com'
BATCH_TEST_SIZE=100
class Tester(object):
    def __init__(self):
        self.redis=RedisClient()
    async def test_single_proxy(self,proxy):
        """
        测试单个代理
        :param proxy: 单个代理
        :return: None
        """
        conn=aiohttp.TCPConnector(verify_sal=False)
        async with aiohttp.ClientSession(connector=conn)as session:
            try:
                if isinstance(proxy,bytes):
                    proxy=proxy.decode('utf-8')
                real_proxy='http://'+proxy
                print('正在测试',proxy)
                async with session.get(TEST_URL,proxy=real_proxy,timeout=15) as response:
                    if response.status in VALID_STATUS_CODES:
                        self.redis.max(proxy)
                        print('代理可用',proxy)
                    else:
                        self.redis.decrease(proxy)
                        print('请求响应码不合法',proxy)
            except(ClientError,clientConnectorError,TimeoutError,AttributeError):
                self.redis.decrease(proxy)
                print('代理请求失败',proxy)
    #获取所有的代理列表
    def run(self):
        """
        测试主函数
        :return: None
        """
        print('测试器开始运行')
        try:
            proxies=self.redis.all()
            loop=asyncio.get_event_loop()
            #批量测试
            for i in range(0,len(proxies),BATCH_TEST_SIZE):
                test_proxies=proxies[i:i+BATCH_TEST_SIZE]
                tasks=[self.test_single_proxy(proxy) for proxy in test_proxies]
                loop.run_until_complete(asyncio.wait(tasks))
                time.sleep(5)
        except Exception as e:
            print('测试器发送错误',e.args)

接口模块

from flask import Flask,g
from db import RedisClient
__all__=['app']
app=Flask(__name__)

def get_conn():
    if not hasattr(g,'redis'):
        g.redis=RedisClient()
    return g.redis
@app.route('/')
def index():
    return '<h2>Welcome to Proxy Pool System</h2>'

@app.route('/random')
def get_proxy():
    """
    获取随机可用代理
    :return: 随机代理
    """
    conn=get_conn()
    return conn.random()
@app.route('/count')
def get_counts():
    """
    获取代理池总量
    :return: 代理池总量
    """
    conn=get_conn()
    return str(conn.count())

调度模块

TEST_CYCLE=20
GETTER_CYCLE=20
TESTER_ENABLD=True
GETTER_ENABLD=True
API_ENABLD=True
from multiprocessing import Process
from api import app
from getter import Getter
from tester import Tester

class Scheduler():
    def schedule_tester(self,cycle=TEST_CYCLE):
        """
        定时测试代理
        :param cycle:
        :return:
        """
        tester=Tester()
        while True:
            print('测试器开始运行')
            tester.run()
            time.sleep(cycle)
    def schedule_api(self):
        """
        开启API
        :return:
        """
        app.run(API_HOST,API_PORT)
    def run(self):
        print('代理池开始运行')
        if TESTER_ENABLD:
            tester_process=Process(target=self.schedule_tester)
            tester_process.start()
        if GETTER_ENABLD:
            getter_process=Process(target=self.schedule_getter)
            getter_process=start()
        if API_ENABLD:
            api_process=Process(target=self.schedule_api())
            api_process.start()
if __name__ == '__main__':
    app.run()

付费代理

• 讯代理：提供接口获取海量代理，按天或者按量收费。
• 阿布云代理：搭建了代理隧道，直接设置固定域名代理。

ADSL拨号代理

ADSL通过拨号的方式上网，需要输入ADSL账号和密码，每次拨号就更换一个IP。