Scrapy-Redis 使用布隆过滤器 #

# 定义 SimpleBloomFilter 类  
class SimpleBloomFilter(object):  
    """ 简单的布隆过滤器实现 """  
    def __init__(self, bit_size=10000, hash_count=3, start_seed=41):  
        # 初始化布隆过滤器的位数组大小  
        self.bit_size = bit_size  
        # 初始化哈希函数的数量  
        self.hash_count = hash_count  
        # 初始化哈希函数的种子值  
        self.start_seed = start_seed  
        # 初始化位数组  
        self.initialize()  
  
    # 初始化位数组  
    def initialize(self):  
        # 使用 bitarray 库初始化位数组  
        self.bit_array = bitarray(self.bit_size)  
        # 将位数组的所有位都设置为 0
        self.bit_array.setall(0)  
  
    # 向布隆过滤器中添加数据  
    def add(self, data):  
        # 获取数据对应的哈希值在位数组中的位置  
        bit_points = self.get_hash_points(data)  
        # 将这些位置上的位都设置为 1
        for index in bit_points:  
            self.bit_array[index] = 1  
  
    # 判断数据是否在布隆过滤器中  
    def is_contain(self, data):  
        # 获取数据对应的哈希值在位数组中的位置  
        bit_points = self.get_hash_points(data)  
        # 获取这些位置上的位的值，并组成列表  
        result = [self.bit_array[index] for index in bit_points]  
        # 如果所有位置上的位的值都为 1，则说明数据可能在布隆过滤器中  
        return all(result)  
  
    # 计算数据在位数组中的哈希值所在的位置  
    def get_hash_points(self, data):  
        return [  
            mmh3.hash(data, index) % self.bit_size  
            for index in range(self.start_seed, self.start_seed + self.hash_count)  
        ]

bloom_filter = SimpleBloomFilter(bit_size=10000, hash_count=6)  
bloom_filter.add('python')  
bloom_filter.add('scrapy')  
print(bloom_filter.is_contain('python'))  
print(bloom_filter.is_contain('scrapy'))  
print(bloom_filter.is_contain('scrapy-redis'))

# 导入 pybloom_live 库中的布隆过滤器类  
from pybloom_live import BloomFilter  
  
# 定义两个 URL 地址  
url1 = 'https://www.baidu.com'  
url2 = 'https://www.qq.com'  
  
# 创建一个容量为 1000 的布隆过滤器对象  
bf = BloomFilter(capacity=1000)  
  
# 将 url1 添加到布隆过滤器中  
bf.add(url1)  
  
# 判断 url1 是否在布隆过滤器中，输出 Trueprint(url1 in bf)  
# 判断 url2 是否在布隆过滤器中，输出 Falseprint(url2 in bf)

# 导入 pybloom_live 库中的 ScalableBloomFilter 类
from pybloom_live import ScalableBloomFilter

# 创建一个初始容量为 100，错误率为 0.001 的可扩展布隆过滤器对象
bf = ScalableBloomFilter(initial_capacity=100, error_rate=0.001)

# 定义两个 URL 地址
url1 = 'https://www.baidu.com'
url2 = 'https://www.qq.com'

# 将 url1 添加到可扩展布隆过滤器中
bf.add(url1)

# 判断 url1 是否在可扩展布隆过滤器中，输出 True
print(url1 in bf)
# 判断 url2 是否在可扩展布隆过滤器中，输出 False
print(url2 in bf)

import mmh3  # 导入 mmh3 库，用于生成哈希值  
import redis  # 导入 redis 库，用于实现分布式的缓存系统  
  
  
class SimpleBloomFilterBitmap(object):  
    """ 集合 Redis 中的 bitmap 来实现一个简单的布隆过滤器 """  
    def __init__(self, bf_key, bit_size=10000, hash_count=3, start_seed=41):  
        """  
        初始化布隆过滤器对象  
        :param bf_key: 用于在 Redis 中存储数据的 key
        :param bit_size: bitmap 的长度（默认为 10000）  
        :param hash_count: 哈希函数的个数（默认为 3）  
        :param start_seed: 哈希函数的种子值（默认为 41）  
        """
        self.bf_key = bf_key  
        self.bit_size = bit_size  
        self.hash_count = hash_count  
        self.start_seed = start_seed  
        self.client = redis.StrictRedis(host='127.0.0.1')  # 连接 Redis 客户端  
  
    def add(self, data):  
        """  
        将数据添加到布隆过滤器中  
        :param data: 待添加的数据  
        """
        bit_points = self._get_hash_points(data)  # 获取数据对应的 bitmap 索引  
        for index in bit_points:  
            self.client.setbit(self.bf_key, index, 1)  # 将 bitmap 对应位置置为 1  
            
    def madd(self, mdata):  
        """  
        将多个数据添加到布隆过滤器中  
        :param mdata: 待添加的数据，可以是单个数据或数据列表  
        """        
        if isinstance(mdata, list):  
            for data in mdata:  
                self.add(data)  
        else:  
            self.add(mdata)  
  
    def exists(self, data):  
        """  
        判断数据是否在布隆过滤器中  
        :param data: 待查询的数据  
        :return: 若数据可能在布隆过滤器中，则返回 True，否则返回 False       
        """        
        bit_points = self._get_hash_points(data)  # 获取数据对应的 bitmap 索引  
        result = [  
            self.client.getbit(self.bf_key, index) for index in bit_points  # 获取 bitmap 对应位置的值  
        ]  
        return all(result)  # 若 bitmap 的对应位置都为 1，则返回 True，否则返回 False  
        
    def mexists(self, mdata):  
        """  
        判断多个数据是否在布隆过滤器中  
        :param mdata: 待查询的数据，可以是单个数据或数据列表  
        :return: 包含数据及其是否在布隆过滤器中的字典  
        """        
        result = {}  
        if isinstance(mdata, list):  
            for data in mdata:  
                result[data] = self.exists(data)  
        else:  
            result[mdata] = mdata  
        return result  
  
    def _get_hash_points(self, data):  
        """  
        用 mmh3 哈希算法，对数据进行 hash_count 次哈希，产生多个哈希值  
        并对每个哈希值取余，得到该哈希值在 bitmap 中的索引位置  
        :param data: 待哈希的数据  
        :return: 数据对应的 bitmap 索引列表  
        """        
        return [  
            mmh3.hash(data, index) % self.bit_size  
            for index in range(self.start_seed, self.start_seed + self.hash_count)  
        ]

if __name__ == '__main__':  
    # 创建 SimpleBloomFilterBitmap 对象，并指定 Redis key 为 'bf_test'    bloom_filter_bitmap = SimpleBloomFilterBitmap(bf_key='bf_test')  
    # 添加数据 'test01' 到布隆过滤器中  
    bloom_filter_bitmap.add('test01')  
    # 添加数据 'test02' 到布隆过滤器中  
    bloom_filter_bitmap.add('test02')  
    # 批量添加数据 ['test03', 'test04'] 到布隆过滤器中  
    bloom_filter_bitmap.madd(['test03', 'test04'])  
    # 检查数据 'test01' 是否在布隆过滤器中  
    print(bloom_filter_bitmap.exists('test01'))  
    # 检查数据 'test02' 是否在布隆过滤器中  
    print(bloom_filter_bitmap.exists('test02'))  
    # 批量检查数据 ['test01', 'test03', 'test04', 'test08', 'test09'] 是否在布隆过滤器中  
    print(bloom_filter_bitmap.mexists(['test01', 'test03', 'test04', 'test08', 'test09']))

# 导入 redisbloom 的客户端类 Client
from redisbloom.client import Client

# 创建一个 Client 实例，连接 Redis 数据库的地址为 '127.0.0.1'，端口为 6379
rb = Client(host='127.0.0.1', port=6379)

# 在 Redis 的 Bloom Filter 中添加两个元素 'baidu' 和 'google'，过滤器的名称为 'urls'
rb.bfAdd('urls', 'baidu')
rb.bfAdd('urls', 'google')

# 判断 'baidu' 是否在名为 'urls' 的 Bloom Filter 中，返回值为 True（1）
print(rb.bfExists('urls', 'baidu'))  # out: 1

# 判断 'tencent' 是否在名为 'urls' 的 Bloom Filter 中，返回值为 False（0）
print(rb.bfExists('urls', 'tencent'))  # out: 0

# 在名为 'urls' 的 Bloom Filter 中添加两个元素 'a' 和 'b'
rb.bfMAdd('urls', 'a', 'b')

# 判断多个元素是否在名为 'urls' 的 Bloom Filter 中，返回值为列表 [1, 1, 0]，分别表示 'google'、'baidu'、'tencent' 是否在 Bloom Filter 中
print(rb.bfMExists('urls', 'google', 'baidu', 'tencent'))  # out: [1, 1, 0]

# 如果你的 scrapy_redis 版本是 <= 0.7.1，请使用这个调度器
SCHEDULER = "scrapy_redis_bloomfilter.scheduler.Scheduler"

# 通过 redis 确保所有爬虫使用相同的去重过滤器
DUPEFILTER_CLASS = "scrapy_redis_bloomfilter.dupefilter.RFPDupeFilter"

# Redis 数据库的 URL 地址
REDIS_URL = 'redis://localhost:6379'

# 使用的哈希函数数量，默认为 6
BLOOMFILTER_HASH_NUMBER = 6

# Bloom 过滤器使用的内存位数，30 表示使用 2^30 = 128MB 内存，默认为 10
BLOOMFILTER_BIT = 10

# 是否持久化
SCHEDULER_PERSIST = True

SCHEDULER = "scrapy_redis_bf.scheduler.Scheduler"

DUPEFILTER_CLASS = "scrapy_redis_bf.dupefilter.RFPDupeFilter"
# 默认是通过spider的name来创建redis key
SCHEDULER_DUPEFILTER_ATTR = "name"

# 格式：redis://[:password@]host[:port][/database][?[timeout=timeout[d|h|m|s|ms|us|ns]][&database=database]]
REDIS_URL = 'redis://localhost:6379'
# 错误率
BLOOMFILTER_ERRORRATE = 0.001
# 去重量
BLOOMFILTER_CAPACITY = 10000