python爬虫-代理池项目需求（domain.py）

1. 代理池概述1.1 什么是代理池代理池就是有代理IP组成的池子, 它可以提供多个稳定可用的代理IP1.2 为什么要实现代理池（防止ip反爬虫）从一堆不稳定代理IP中,抽取高可用代理IP, 给爬虫使用1.3 代理池开发环境开发语言： Python3主要技术：requests，lxml，pymongo，Flask2. 代理池的设计2.1 代理池的工作流程代理IP采集模块: 抓取代理IP -&gt

IT瘾君

1431人浏览 · 2021-11-23 14:10:23

IT瘾君 · 2021-11-23 14:10:23 发布

文章目录

python编程快速上手（持续更新中…）

python编程快速上手（持续更新中…）

python爬虫热点项目（Flask )

1. 代理池概述

1.1 什么是代理池

代理池就是有代理IP组成的池子, 它可以提供多个稳定可用的代理IP

1.2 为什么要实现代理池（防止ip反爬虫）

从一堆不稳定代理IP中,抽取高可用代理IP, 给爬虫使用

1.3 代理池开发环境

开发语言： Python3
主要技术：requests，lxml，pymongo，Flask

2. 代理池的设计

2.1 代理池的工作流程

在这里插入图片描述
代理IP采集模块: 抓取代理IP -> 校验代理IP可用性 -> 如果可用 -> 数据库(代理池)
检验模块: 读取数据库的代理IP -> 校验代理IP可用性 -> 更新或删除代理IP
代理API模块: 从数据库中获取高可用代理IP, 给爬虫使用.

2.2 代理池的模块及其作用

五大核心模块
代理IP采集模块: 采集代理IP, 把可用代理IP, 入库
校验模块: 检测代理的可用性: 响应速度, 协议类型, 匿名程度
数据库模块: 对代理IP进行增删改查的操作
检测模块: 获取数据库中代理IP, 进行处理, 保证代理IP的可用性
API模块: 提供爬虫或高可用代理IP 和指定代理不可用域名的接口.

其他模块
数据模型: 用于封装代理IP信息
main.py: 启动的统一入口
utils: 工具模块
http.py : 提供随机的User-Agent
log.py : 日志模块, 用于记录日志
settings.py: 配置文件, 用于对项目进行配置

2.3 代理池的项目结构

在这里插入图片描述
项目结构中模块及其作用：

mongo_pool模块：代理IP增删改查模块

proxy_spider包：采集代理IP

httpbin_validator模块：检测代理的可用性—speed，协议类型，匿名程度（原因: 网站上所标注的协议类型和匿名类型是不准确的）

proxy_api模块：提供爬虫或稳定可用代理IP和指定不可用域名的接口

proxy_test模块：获取数据库中代理IP，定期检测可用性

dbmodle模块：代理IP数据模型

main模块：程序入口

http模块：提供随机User-Agent的请求头

log模块：记录日志

settings模块：项目配置文件

3. 实现代理池步骤

代理池实现思路: 先实现不依赖其他模块的基础模块, 然后再实现具体功能模块.

3.1. 实现代理IP的数据模型类（domain.py）

from settings import MAX_SCORE

"""
4. 定义代理IP的数据模型类
目标: 定义代理IP的数据模型类
步骤:

1. 定义Proxy类, 继承object
2. 实现__init__方法, 负责初始化, 包含如下字段:
    ip: 代理的IP地址
    port: 代理IP的端口号
    protocol: 代理IP支持的协议类型,http是0, https是1, https和http都支持是2
    nick_type: 代理IP的匿名程度, 高匿:0, 匿名: 1, 透明:2
    speed: 代理IP的响应速度, 单位s
    area: 代理IP所在地区
    score: 代理IP的评分, 用于衡量代理的可用性; 默认分值可以通过配置文件进行配置. 在进行代理可用性检查的时候, 每遇到一次请求失败就减1份, 减到0的时候从池中删除. 如果检查代理可用, 就恢复默认分值
    disable_domains: 不可用域名列表, 有些代理IP在某些域名下不可用, 但是在其他域名下可用
    在配置文件: settings.py 中 定义MAX_SCORE = 50, 表示代理IP的默认最高分数
3. 提供 __str__ 方法, 返回数据字符串
"""

class Proxy(object):

    def __init__(self, ip, port, protocol=-1, nick_type=-1, speed=-1, area=None, score=MAX_SCORE, disable_domains=[]):
        # ip: 代理的IP地址
        self.ip = ip
        # port: 代理IP的端口号
        self.port = port
        # protocol: 代理IP支持的协议类型, http是0, https是1, https和http都支持是2
        self.protocol = protocol
        # nick_type: 代理IP的匿名程度, 高匿: 0, 匿名: 1, 透明: 2
        self.nick_type = nick_type
        # speed: 代理IP的响应速度, 单位s
        self.speed = speed
        # area: 代理IP所在地区
        self.area = area
        # score: 代理IP的评分, 用于衡量代理的可用性;
        self.score = score
        # 默认分值可以通过配置文件进行配置.在进行代理可用性检查的时候, 每遇到一次请求失败就减1份, 减到0的时候从池中删除.如果检查代理可用, 就恢复默认分值
        # disable_domains: 不可用域名列表, 有些代理IP在某些域名下不可用, 但是在其他域名下可用
        self.disable_domains = disable_domains

    # 3. 提供 __str__ 方法, 返回数据字符串
    def __str__(self):
        # 返回数据字符串
        return str(self.__dict__)

3.2. 实现日志记录模块（log.py）

目的：
能够方便的对程序进行调试
能够记录程序的运行状态
记录错误信息

实现：
日志模块在网上有很多现成的实现, 我们开发的时候，拿来用就好了

把日志模块中的相关配置信息放到配置文件中
修改日志模块代码，使用配置文件中的配置信息

# utils/log.py
import sys
import logging

# 导入settings中日志配置信息
from settings import LOG_FMT, LOG_DATEFMT, LOG_FILENAME, LOG_LEVEL

class Logger(object):

    def __init__(self):
        # 1. 获取一个logger对象
        self._logger = logging.getLogger()
        # 2. 设置format对象
        self.formatter = logging.Formatter(fmt=LOG_FMT,datefmt=LOG_DATEFMT)
        # 3. 设置日志输出
        # 3.1 设置文件日志模式
        self._logger.addHandler(self._get_file_handler(LOG_FILENAME))
        # 3.2 设置终端日志模式
        self._logger.addHandler(self._get_console_handler())
        # 4. 设置日志等级
        self._logger.setLevel(LOG_LEVEL)

    def _get_file_handler(self, filename):
        '''返回一个文件日志handler'''
        # 1. 获取一个文件日志handler
        filehandler = logging.FileHandler(filename=filename,encoding="utf-8")
        # 2. 设置日志格式
        filehandler.setFormatter(self.formatter)
        # 3. 返回
        return filehandler

    def _get_console_handler(self):
        '''返回一个输出到终端日志handler'''
        # 1. 获取一个输出到终端日志handler
        console_handler = logging.StreamHandler(sys.stdout)
        # 2. 设置日志格式
        console_handler.setFormatter(self.formatter)
        # 3. 返回handler
        return console_handler

    @property
    def logger(self):
        return self._logger

# 初始化并配一个logger对象，达到单例的
# 使用时，直接导入logger就可以使用
logger = Logger().logger

if __name__ == '__main__':
    logger.debug("调试信息")
    logger.info("状态信息")
    logger.warning("警告信息")
    logger.error("错误信息")
    logger.critical("严重错误信息")

3.3. 实现随机获取User-Agent 的请求头模块（http.py）

准备User-Agent的列表
实现一个方法, 获取随机User-Agent的请求头

import random

"""
5.2 http模块
我在从代理IP网站上抓取代理IP 和 检验代理IP时候, 为了不容易不服务器识别为是一个爬虫, 我们最好提供随机的User-Agent请求头.

目标: 获取随机User-Agent的请求头
步骤:
   1. 准备User-Agent的列表
   2. 实现一个方法, 获取随机User-Agent的请求头
"""

#   1. 准备User-Agent的列表
USER_AGENTS = [
    "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; AcooBrowser; .NET CLR 1.1.4322; .NET CLR 2.0.50727)",
    "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0; Acoo Browser; SLCC1; .NET CLR 2.0.50727; Media Center PC 5.0; .NET CLR 3.0.04506)",
    "Mozilla/4.0 (compatible; MSIE 7.0; AOL 9.5; AOLBuild 4337.35; Windows NT 5.1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)",
    "Mozilla/5.0 (Windows; U; MSIE 9.0; Windows NT 9.0; en-US)",
    "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0; .NET CLR 3.5.30729; .NET CLR 3.0.30729; .NET CLR 2.0.50727; Media Center PC 6.0)",
    "Mozilla/5.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0; WOW64; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; .NET CLR 1.0.3705; .NET CLR 1.1.4322)",
    "Mozilla/4.0 (compatible; MSIE 7.0b; Windows NT 5.2; .NET CLR 1.1.4322; .NET CLR 2.0.50727; InfoPath.2; .NET CLR 3.0.04506.30)",
    "Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-CN) AppleWebKit/523.15 (KHTML, like Gecko, Safari/419.3) Arora/0.3 (Change: 287 c9dfb30)",
    "Mozilla/5.0 (X11; U; Linux; en-US) AppleWebKit/527+ (KHTML, like Gecko, Safari/419.3) Arora/0.6",
    "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.1.2pre) Gecko/20070215 K-Ninja/2.1.1",
    "Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-CN; rv:1.9) Gecko/20080705 Firefox/3.0 Kapiko/3.0",
    "Mozilla/5.0 (X11; Linux i686; U;) Gecko/20070322 Kazehakase/0.4.5",
    "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.8) Gecko Fedora/1.9.0.8-1.fc10 Kazehakase/0.5.6",
    "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.56 Safari/535.11",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/535.20 (KHTML, like Gecko) Chrome/19.0.1036.7 Safari/535.20",
    "Opera/9.80 (Macintosh; Intel Mac OS X 10.6.8; U; fr) Presto/2.9.168 Version/11.52",
    "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.11 TaoBrowser/2.0 Safari/536.11",
    "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.1 (KHTML, like Gecko) Chrome/21.0.1180.71 Safari/537.1 LBBROWSER",
    "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E; LBBROWSER)",
    "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; QQDownload 732; .NET4.0C; .NET4.0E; LBBROWSER)",
    "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.84 Safari/535.11 LBBROWSER",
    "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; WOW64; Trident/5.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E)",
    "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E; QQBrowser/7.0.3698.400)",
    "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; QQDownload 732; .NET4.0C; .NET4.0E)",
    "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; SV1; QQDownload 732; .NET4.0C; .NET4.0E; 360SE)",
    "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; QQDownload 732; .NET4.0C; .NET4.0E)",
    "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; WOW64; Trident/5.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E)",
    "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.1 (KHTML, like Gecko) Chrome/21.0.1180.89 Safari/537.1",
    "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.1 (KHTML, like Gecko) Chrome/21.0.1180.89 Safari/537.1",
    "Mozilla/5.0 (iPad; U; CPU OS 4_2_1 like Mac OS X; zh-cn) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8C148 Safari/6533.18.5",
    "Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:2.0b13pre) Gecko/20110307 Firefox/4.0b13pre",
    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:16.0) Gecko/20100101 Firefox/16.0",
    "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11",
    "Mozilla/5.0 (X11; U; Linux x86_64; zh-CN; rv:1.9.2.10) Gecko/20100922 Ubuntu/10.10 (maverick) Firefox/3.6.10"
]

# 实现一个方法, 获取随机User-Agent的请求头
def get_request_headers():
    headers = {
        'User-Agent': random.choice(USER_AGENTS),
        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
        'Accept-Language': 'en-US,en;q=0.5',
        'Connection': 'keep-alive',
        'Accept-Encoding': 'gzip, deflate',
    }

    return headers

if __name__ == '__main__':
    print(get_request_headers())
    print(get_request_headers())
    print(get_request_headers())

3.4. 校验代理IP的协议类型、匿名程度，速度（httpbin_validator.py）

代理IP速度: 就是从发送请求到获取响应的时间间隔

匿名程度检查:
对 http://httpbin.org/get 或 https://httpbin.org/get 发送请求, 获取响应数据
如果响应的origin 中有’,'分割的两个IP就是透明代理IP
如果响应的headers 中包含 Proxy-Connection 说明是匿名代理IP
否则就是高匿代理IP

检查代理IP协议类型
如果 http://httpbin.org/get 发送请求可以成功, 说明支持http协议
如果 https://httpbin.org/get 发送请求可以成功, 说明支持https协议

import time
import requests
import json

from utils.http import get_request_headers
from settings import TEST_TIMEOUT
from utils.log import logger
from domain import Proxy
"""
 实现代理池的校验模块
目标: 检查代理IP速度,匿名程度以及支持的协议类型.
步骤:

检查代理IP速度 和 匿名程度;
    1. 代理IP速度: 就是从发送请求到获取响应的时间间隔
    2. 匿名程度检查:
        1. 对 http://httpbin.org/get 或 https://httpbin.org/get 发送请求
        2. 如果 响应的origin 中有','分割的两个IP就是透明代理IP
        3. 如果 响应的headers 中包含 Proxy-Connection 说明是匿名代理IP
        4. 否则就是高匿代理IP
检查代理IP协议类型
    如果 http://httpbin.org/get 发送请求可以成功, 说明支持http协议
    如果 https://httpbin.org/get 发送请求可以成功, 说明支持https协议
"""

def check_proxy(proxy):
    """
    用于检查指定 代理IP 响应速度, 匿名程度, 支持协议类型
    :param proxy: 代理IP模型对象
    :return: 检查后的代理IP模型对象
    """

    # 准备代理IP字典
    proxies = {
        'http':'http://{}:{}'.format(proxy.ip, proxy.port),
        'https':'https://{}:{}'.format(proxy.ip, proxy.port),
    }

    # 测试该代理IP
    http, http_nick_type, http_speed = __check_http_proxies(proxies)
    https, https_nick_type, https_speed = __check_http_proxies(proxies, False)
    # 代理IP支持的协议类型, http是0, https是1, https和http都支持是2
    if http and https:
        proxy.protocol = 2
        proxy.nick_type = http_nick_type
        proxy.speed = http_speed
    elif http:
        proxy.protocol = 0
        proxy.nick_type = http_nick_type
        proxy.speed = http_speed
    elif https:
        proxy.protocol = 1
        proxy.nick_type = https_nick_type
        proxy.speed = https_speed
    else:
        proxy.protocol = -1
        proxy.nick_type = -1
        proxy.speed = -1

    return proxy


def __check_http_proxies(proxies, is_http=True):
    # 匿名类型: 高匿: 0, 匿名: 1, 透明: 2
    nick_type = -1
    # 响应速度, 单位s
    speed = -1

    if is_http:
        test_url = 'http://httpbin.org/get'
    else:
        test_url = 'https://httpbin.org/get'

    try:
        # 获取开始时间
        start = time.time()
        # 发送请求, 获取响应数据
        response = requests.get(test_url, headers=get_request_headers(), proxies=proxies, timeout=TEST_TIMEOUT)

        if response.ok:
            # 计算响应速度
            speed =  round(time.time() - start, 2)
            # 匿名程度
            # 把响应的json字符串, 转换为字典
            dic = json.loads(response.text)
            # 获取来源IP: origin
            origin = dic['origin']
            proxy_connection = dic['headers'].get('Proxy-Connection', None)
            if ',' in origin:
                #    1. 如果 响应的origin 中有','分割的两个IP就是透明代理IP
                nick_type = 2
            elif proxy_connection:
                #    2. 如果 响应的headers 中包含 Proxy-Connection 说明是匿名代理IP
                nick_type = 1
            else:
                #  3. 否则就是高匿代理IP
                nick_type = 0

            return True, nick_type, speed
        return False, nick_type, speed
    except Exception as ex:
        # logger.exception(ex)
        return False, nick_type, speed


if __name__ == '__main__':
    # ping www.baidu.com 获取ip
    proxy = Proxy('112.80.248.75', port='80')
    print(check_proxy(proxy))

3.5. 实现数据库模块（增删改查功能和api功能—mongo_pool.py）

1.在init中, 建立数据连接, 获取要操作的集合, 在 del 方法中关闭数据库连接

2.提供基础的增删改查功能
1.实现插入功能
2.实现修改该功能
3.实现删除代理: 根据代理的IP删除代理
4.查询所有代理IP的功能

3.提供代理API模块使用的功能
1.实现查询功能: 根据条件进行查询, 可以指定查询数量, 先分数降序, 速度升序排, 保证优质的代理IP在上面.
2.实现根据协议类型和要访问网站的域名, 获取代理IP列表
3.实现根据协议类型和要访问网站的域名, 随机获取一个代理IP
4.实现把指定域名添加到指定IP的disable_domain列表中.

from pymongo import MongoClient
import pymongo
import random

from settings import MONGO_URL
from utils.log import logger

from domain import Proxy

"""
7. 实现代理池的数据库模块
作用: 用于对proxies集合进行数据库的相关操作
目标: 实现对数据库增删改查相关操作
步骤:
1. 在init中, 建立数据连接, 获取要操作的集合, 在 del 方法中关闭数据库连接

2.提供基础的增删改查功能
    2.1 实现插入功能
    2.2 实现修改该功能
    2.3 实现删除代理: 根据代理的IP删除代理
    2.4 查询所有代理IP的功能
3. 提供代理API模块使用的功能
    3.1 实现查询功能: 根据条件进行查询, 可以指定查询数量, 先分数降序, 速度升序排, 保证优质的代理IP在上面.
    3.2 实现根据协议类型 和 要访问网站的域名, 获取代理IP列表
    3.3 实现根据协议类型 和 要访问网站的域名, 随机获取一个代理IP
    3.4 实现把指定域名添加到指定IP的disable_domain列表中.
"""

class MongoPool(object):

    def __init__(self):
        # 1.1. 在init中, 建立数据连接
        self.client = MongoClient(MONGO_URL)
        # 1.2  获取要操作的集合
        self.proxies = self.client['proxies_pool']['proxies']

    def __del__(self):
        # 1.3 关闭数据库连接
        self.client.close()

    def insert_one(self, proxy):
        """2.1 实现插入功能"""

        count = self.proxies.count_documents({'_id': proxy.ip})
        if count == 0:
            # 我们使用proxy.ip作为, MongoDB中数据的主键: _id
            dic = proxy.__dict__
            dic['_id'] = proxy.ip
            self.proxies.insert_one(dic)
            logger.info('插入新的代理:{}'.format(proxy))
        else:
            logger.warning("已经存在的代理:{}".format(proxy))


    def update_one(self, proxy):
        """2.2 实现修改该功能"""
        self.proxies.update_one({'_id': proxy.ip}, {'$set':proxy.__dict__})

    def delete_one(self, proxy):
        """2.3 实现删除代理: 根据代理的IP删除代理"""
        self.proxies.delete_one({'_id': proxy.ip})
        logger.info("删除代理IP: {}".format(proxy))

    def find_all(self):
        """2.4 查询所有代理IP的功能"""
        cursor = self.proxies.find()
        for item in cursor:
            # 删除_id这个key
            item.pop('_id')
            proxy = Proxy(**item)
            yield proxy

    def find(self, conditions={}, count=0):
        """
        3.1 实现查询功能: 根据条件进行查询, 可以指定查询数量, 先分数降序, 速度升序排, 保证优质的代理IP在上面.
        :param conditions: 查询条件字典
        :param count: 限制最多取出多少个代理IP
        :return: 返回满足要求代理IP(Proxy对象)列表
        """
        cursor = self.proxies.find(conditions, limit=count).sort([
            ('score', pymongo.DESCENDING),('speed', pymongo.ASCENDING)
        ])

        # 准备列表, 用于存储查询处理代理IP
        proxy_list = []
        # 遍历 cursor
        for item in cursor:
            item.pop('_id')
            proxy = Proxy(**item)
            proxy_list.append(proxy)

        # 返回满足要求代理IP(Proxy对象)列表
        return proxy_list

    def get_proxies(self, protocol=None, domain=None, count=0, nick_type=0):
        """
        3.2 实现根据协议类型 和 要访问网站的域名, 获取代理IP列表
        :param protocol: 协议: http, https
        :param domain: 域名: jd.com
        :param count:  用于限制获取多个代理IP, 默认是获取所有的
        :param nick_type: 匿名类型, 默认, 获取高匿的代理IP
        :return: 满足要求代理IP的列表
        """
        # 定义查询条件
        conditions = {'nick_type': nick_type}
        # 根据协议, 指定查询条件
        if protocol is None:
            # 如果没有传入协议类型, 返回支持http和https的代理IP
            conditions['protocol'] = 2
        elif protocol.lower() == 'http':
            conditions['protocol'] = {'$in': [0, 2]}
        else:
            conditions['protocol'] = {'$in': [1, 2]}

        if domain:
            conditions['disable_domains'] = {'$nin': [domain]}


        # 满足要求代理IP的列表
        return self.find(conditions, count=count)

    def random_proxy(self, protocol=None, domain=None, count=0, nick_type=0):
        """
        3.3 实现根据协议类型 和 要访问网站的域名, 随机获取一个代理IP
        :param protocol: 协议: http, https
        :param domain: 域名: jd.com
        :param count:  用于限制获取多个代理IP, 默认是获取所有的
        :param nick_type: 匿名类型, 默认, 获取高匿的代理IP
        :return: 满足要求的随机的一个代理IP(Proxy对象)
        """
        proxy_list = self.get_proxies(protocol=protocol, domain=domain, count=count, nick_type=nick_type)
        # 从proxy_list列表中, 随机取出一个代理IP返回
        return random.choice(proxy_list)


    def disable_domain(self, ip, domain):
        """
        3.4 实现把指定域名添加到指定IP的disable_domain列表中.
        :param ip: IP地址
        :param domain: 域名
        :return: 如果返回True, 就表示添加成功了, 返回False添加失败了
        """
        # print(self.proxies.count_documents({'_id': ip, 'disable_domains':domain}))

        if self.proxies.count_documents({'_id': ip, 'disable_domains':domain}) == 0:
            # 如果disable_domains字段中没有这个域名, 才添加
            self.proxies.update_one({'_id':ip}, {'$push': {'disable_domains': domain}})
            return True
        return False

if __name__ == '__main__':
    mongo = MongoPool()
    # proxy = Proxy('202.104.113.35', port='53281')
    # # proxy = Proxy('202.104.113.36', port='53281')
    # mongo.insert_one(proxy)

    # proxy = Proxy('202.104.113.35', port='8888')
    # mongo.update_one(proxy)

    # proxy = Proxy('202.104.113.35', port='8888')
    # mongo.delete_one(proxy)

    # for proxy in mongo.find_all():
    #     print(proxy)

    # # dic = { "ip" : "202.104.113.38", "port" : "53281", "protocol" : 0, "nick_type" : 0, "speed" : 8.2, "area" : None, "score" : 50, "disable_domains" : [ "jd.com"] }
    # # dic = { "ip" : "202.104.113.39", "port" : "53281", "protocol" : 1, "nick_type" : 0, "speed" : 1.2, "area" : None, "score" : 50, "disable_domains" : [ "taobao.com"] }
    # # dic = { "ip" : "202.104.113.40", "port" : "53281", "protocol" : 2, "nick_type" : 0, "speed" : 4.0, "area" : None, "score" : 50, "disable_domains" : []}
    # # dic = { "ip" : "202.104.113.41", "port" : "53281", "protocol" : 2, "nick_type" : 0, "speed" : -1, "area" : None, "score" : 49, "disable_domains" : []}
    # proxy = Proxy(**dic)
    # mongo.insert_one(proxy)

    # # for proxy in mongo.find():
    # for proxy in mongo.find({'protocol':2}, count=1):
    #     print(proxy)

    # for proxy in mongo.get_proxies(protocol='https'):
    # for proxy in mongo.get_proxies(protocol='http', domain='taobao.com'):
    #     print(proxy)

    # mongo.disable_domain('202.104.113.38', 'taobao.com')