python模块之redisbloom redis布隆过滤器

一、简介

RedisBloom 是一个 Redis 模块，提供了布隆过滤器（Bloom Filter）、计数器（Count-Min Sketch）、Top-K（Top-K）、Top-K with expiry（Top-K with Expiration）和多样本（Cuckoo Filter）等数据结构的实现。它通过将这些数据结构存储在 Redis 中，为应用程序提供了高效的数据处理和查询功能。
以下是 RedisBloom 的一些主要特点和用途：

1. 布隆过滤器（Bloom Filter）：布隆过滤器是一种高效的数据结构，用于快速判断一个元素是否存在于集合中。它可以在常数时间内进行查询，并且具有很低的内存消耗。RedisBloom 提供了布隆过滤器的实现，可以用于去重、快速查找和过滤等应用场景。
2. 计数器（Count-Min Sketch）：计数器是一种用于近似计数的数据结构，可以用于统计元素出现的频率。RedisBloom 提供了 Count-Min Sketch 的实现，可以用于统计热门元素、流量分析等应用。
3. Top-K：Top-K 是一种用于获取频率最高的元素的数据结构。RedisBloom 提供了 Top-K 的实现，可以高效地获取出现频率最高的元素。
4. Top-K with expiry：Top-K with expiry 是一种带有过期时间的 Top-K 数据结构，可以设置元素的过期时间，并在过期后自动删除。这对于需要跟踪热门元素并定期更新的应用非常有用。
5. 多样本（Cuckoo Filter）：多样本是一种用于快速查找元素的数据结构，它可以在常数时间内进行查询，并且具有较低的内存消耗。RedisBloom 提供了多样本的实现，可以用于快速查找元素。
   使用 RedisBloom，你可以在 Redis 中利用这些数据结构来解决各种实际问题，如去重、近似计数、热门元素统计、快速查找等。
   RedisBloom 的官方文档：https://redis.io/docs/data-types/probabilistic/bloom-filter/

二、安装

pip install redisbloom

三、RedisBloom Python 客户端库中的一些类、函数和方法的简要说明

1. redisbloom.client.Redis：Redis 类，它继承自 Redis 客户端库中的 redis.Redis 类。你可以使用它来连接到 Redis 服务器，并执行 RedisBloom 相关的操作。
2. redisbloom.client.bool_ok()：用于检查 Redis 命令的返回值是否为布尔类型的 OK。
3. redisbloom.client.parseToList()：用于将 Redis 命令的返回值解析为列表。
4. redisbloom.client.spaceHolder()：用于生成 Redis 命令的占位符。
5. redisbloom.client.Client：用于与 RedisBloom 模块进行交互。它提供了一组方法来执行布隆过滤器、计数器、Top-K 等数据结构的操作。
6. redisbloom.client.CFInfo：用于获取布隆过滤器的信息。
7. redisbloom.client.BFInfo：用于获取布隆过滤器的信息。
8. redisbloom.client.CMSInfo：用于获取计数器的信息。
9. redisbloom.client.TDigestInfo：用于获取 TDigest（Top-K 和分位数）的信息。
10. redisbloom.client.TopKInfo：用于获取 Top-K 数据结构的信息。
11. redisbloom.client.Pipeline：用于执行 RedisBloom 操作的批量管道。它可以提高操作的效率。

四、创建RedisBloom过滤器客户端：from redisbloom.client import Client，继承redis

1. redisBloomFilter = Client(host=‘localhost’, port=6379,…)：创建redisbloom过滤器对象
2. redisBloomFilter.appendBucketSize(params, bucket_size): 将 bucket_size 参数添加到 params 中，用于创建 Count-Min Sketch（CMS）过滤器时指定桶的大小。
3. redisBloomFilter.appendCapacity(params, capacity): 将 capacity 参数添加到 params 中，用于创建 Bloom 过滤器或 Count-Min Sketch（CMS）过滤器时指定容量。
4. redisBloomFilter.appendError(params, error): 将 error 参数添加到 params 中，用于创建 Count-Min Sketch（CMS）过滤器时指定误差率。
5. redisBloomFilter.appendExpansion(params, expansion): 将 expansion 参数添加到 params 中，用于创建 Bloom 过滤器时指定扩展因子。
6. redisBloomFilter.appendItems(params, items): 将 items 参数添加到 params 中，用于指定要添加到 Bloom 过滤器或 Count-Min Sketch（CMS）过滤器中的元素。
7. redisBloomFilter.appendItemsAndIncrements(params, items, increments): 将 items 参数和 increments 参数添加到 params 中，用于指定要在 Count-Min Sketch（CMS）过滤器中增加或减少的元素及其增量。
8. redisBloomFilter.appendMaxIterations(params, max_iterations): 将 max_iterations 参数添加到 params 中，用于创建 Count-Min Sketch（CMS）过滤器时指定最大迭代次数。
9. redisBloomFilter.appendNoCreate(params, noCreate): 将 noCreate 参数添加到 params 中，用于指定在 Bloom 过滤器或 Count-Min Sketch（CMS）过滤器不存在时是否创建新的过滤器。
10. redisBloomFilter.appendNoScale(params, noScale): 将 noScale 参数添加到 params 中，用于指定在 Count-Min Sketch（CMS）过滤器中是否进行自动缩放。
11. redisBloomFilter.appendValuesAndWeights(params, items, weights): 将 items 参数和 weights 参数添加到 params 中，用于指定要添加到 Top-K 过滤器中的元素及其权重。
12. redisBloomFilter.appendWeights(params, weights): 将 weights 参数添加到 params 中，用于指定要添加到 Top-K 过滤器中的元素的权重。
13. redisBloomFilter.bfCreate(key, errorRate, capacity, expansion=None, noScale=None): 创建一个 Bloom 过滤器，使用给定的 key、误差率 errorRate、容量 capacity，可选参数包括扩展因子 expansion 和是否进行自动缩放 noScale。
14. redisBloomFilter.bfExists(key, item): 检查 Bloom 过滤器中是否存在指定的 item。
15. redisBloomFilter.bfInfo(key): 获取 Bloom 过滤器的信息，包括误差率、容量、哈希函数数量等。
16. redisBloomFilter.bfInsert(key, items, capacity=None, error=None, noCreate=None, expansion=None, noScale=None): 向 Bloom 过滤器中插入指定的 items，可选参数包括容量 capacity、误差率 error、是否创建新过滤器 noCreate、扩展因子 expansion 和是否进行自动缩放 noScale。
17. redisBloomFilter.bfLoadChunk(key, iter, data): 将序列化的 Bloom 过滤器数据块加载到指定的 key 中。
18. redisBloomFilter.bfMAdd(key, *items): 向 Bloom 过滤器中批量添加多个 items。
19. redisBloomFilter.bfMExists(key, *items): 检查 Bloom 过滤器中多个 items 是否存在。
20. redisBloomFilter.bfScandump(key, iter): 以迭代方式获取 Bloom 过滤器的数据块。
21. redisBloomFilter.cfAdd(key, item): 将指定的 item 添加到 Count-Min Sketch（CMS）过滤器中。
22. redisBloomFilter.cfAddNX(key, item): 当指定的 item 不存在时，将其添加到 Count-Min Sketch（CMS）过滤器中。
23. redisBloomFilter.cfDel(key, item): 从 Count-Min Sketch（CMS）过滤器中删除指定的 item。
24. redisBloomFilter.cfCount(key, item): 获取 Count-Min Sketch（CMS）过滤器中指定 item 的计数。
25. redisBloomFilter.cfCreate(key, capacity, expansion=None, bucket_size=None, max_iterations=None): 创建一个 Count-Min Sketch（CMS）过滤器，使用给定的 key、容量 capacity，可选参数包括扩展因子 expansion、桶大小 bucket_size 和最大迭代次数 max_iterations。
26. redisBloomFilter.cfExists(key, item): 检查 Count-Min Sketch（CMS）过滤器中是否存在指定的 item。
27. redisBloomFilter.cfInfo(key): 获取 Count-Min Sketch（CMS）过滤器的信息，包括容量、桶大小、哈希函数数量等。
28. redisBloomFilter.cfInsert(key, items, capacity=None, nocreate=None): 向 Count-Min Sketch（CMS）过滤器中插入指定的 items，可选参数包括容量 capacity 和是否创建新过滤器 nocreate。
29. redisBloomFilter.cfInsertNX(key, items, capacity=None, nocreate=None): 当指定的 items 不存在时，将其插入到 Count-Min Sketch（CMS）过滤器中。
30. redisBloomFilter.cfLoadChunk(key, iter, data): 将序列化的 Count-Min Sketch（CMS）过滤器数据块加载到指定的 key 中。
31. redisBloomFilter.cfScandump(key, iter): 以迭代方式获取 Count-Min Sketch（CMS）过滤器的数据块。
32. redisBloomFilter.cmsInfo(key): 获取 Count-Min Sketch（CMS）数据结构的信息，包括宽度、深度等。
33. redisBloomFilter.cmsMerge(destKey, numKeys, srcKeys, weights=[]): 将多个 Count-Min Sketch（CMS）数据结构合并到目标数据结构中。
34. redisBloomFilter.cmsQuery(key, *items): 查询 Count-Min Sketch（CMS）数据结构中多个 items 的计数。
35. redisBloomFilter.cmsIncrBy(key, items, increments): 对 Count-Min Sketch（CMS）数据结构中的多个 items 进行增量操作。
36. redisBloomFilter.cmsInitByDim(key, width, depth): 使用指定的宽度 width 和深度 depth 初始化 Count-Min Sketch（CMS）数据结构。
37. redisBloomFilter.cmsInitByProb(key, error, probability): 使用指定的误差率 error 和概率 probability 初始化 Count-Min Sketch（CMS）数据结构。
38. redisBloomFilter.pipeline(transaction=True, shard_hint=None): 创建一个 Redis pipeline 对象，用于批量执行多个命令。
39. redisBloomFilter.tdigestCdf(key, value): 获取 T-Digest 数据结构中小于等于指定 value 的累积分布函数值。
40. redisBloomFilter.tdigestInfo(key): 获取 T-Digest 数据结构的信息，包括压缩率等。
41. redisBloomFilter.tdigestAdd(key, values, weights): 向 T-Digest 数据结构中添加指定的 values 和对应的 weights。
42. redisBloomFilter.tdigestMax(key): 获取 T-Digest 数据结构中的最大值。
43. redisBloomFilter.tdigestCreate(key, compression): 创建一个 T-Digest 数据结构，使用给定的 key 和压缩率 compression。
44. redisBloomFilter.tdigestMerge(toKey, fromKey): 将一个 T-Digest 数据结构从源键 fromKey 合并到目标键 toKey。
45. redisBloomFilter.tdigestMin(key): 获取 T-Digest 数据结构中的最小值。
46. redisBloomFilter.tdigestQuantile(key, quantile): 获取 T-Digest 数据结构中指定分位数 quantile 的值。
47. redisBloomFilter.tdigestReset(key): 重置 T-Digest 数据结构，将其清空。
48. redisBloomFilter.topkCount(key, *items): 获取 Top-K 数据结构中多个 items 的计数。
49. redisBloomFilter.topkInfo(key): 获取 Top-K 数据结构的信息，包括 K 值、宽度、深度等。
50. redisBloomFilter.topkAdd(key, *items): 向 Top-K 数据结构中添加多个 items。
51. redisBloomFilter.topkList(key): 获取 Top-K 数据结构中的前 K 个元素。
52. redisBloomFilter.topkListWithCount(key): 获取 Top-K 数据结构中的前 K 个元素及其计数。
53. redisBloomFilter.topkQuery(key, *items): 查询 Top-K 数据结构中多个 items 的计数。
54. redisBloomFilter.topkReserve(key, k, width, depth, decay): 创建一个 Top-K 数据结构，使用给定的 key、K 值 k、宽度 width、深度 depth 和衰减因子 decay。
55. from redisbloom.client import Client下的常量

    redisBloomFilter.BF_ADD: Bloom 过滤器命令，用于向 Bloom 过滤器中添加元素。
    redisBloomFilter.BF_EXISTS: Bloom 过滤器命令，用于检查元素是否存在于 Bloom 过滤器中。
    redisBloomFilter.BF_INFO: Bloom 过滤器命令，用于获取 Bloom 过滤器的信息。
    redisBloomFilter.BF_INSERT: Bloom 过滤器命令，用于向 Bloom 过滤器中插入元素。
    redisBloomFilter.BF_LOADCHUNK: Bloom 过滤器命令，用于加载 Bloom 过滤器的数据块。
    redisBloomFilter.BF_MADD: Bloom 过滤器命令，用于批量添加多个元素到 Bloom 过滤器中。
    redisBloomFilter.BF_MEXISTS: Bloom 过滤器命令，用于批量检查多个元素是否存在于 Bloom 过滤器中。
    redisBloomFilter.BF_RESERVE: Bloom 过滤器命令，用于创建一个 Bloom 过滤器。
    redisBloomFilter.BF_SCANDUMP: Bloom 过滤器命令，用于以迭代方式获取 Bloom 过滤器的数据块。
    redisBloomFilter.CF_ADD: Count-Min Sketch（CMS）命令，用于向 Count-Min Sketch（CMS）过滤器中添加元素。
    redisBloomFilter.CF_ADDNX: Count-Min Sketch（CMS）命令，用于当元素不存在时向 Count-Min Sketch（CMS）过滤器中添加元素。
    redisBloomFilter.CF_INFO: Count-Min Sketch（CMS）命令，用于获取 Count-Min Sketch（CMS）过滤器的信息。
    redisBloomFilter.CF_DEL: Count-Min Sketch（CMS）命令，用于从 Count-Min Sketch（CMS）过滤器中删除元素。
    redisBloomFilter.CF_RESERVE: Count-Min Sketch（CMS）命令，用于创建一个 Count-Min Sketch（CMS）过滤器。
    redisBloomFilter.CF_COUNT: Count-Min Sketch（CMS）命令，用于获取 Count-Min Sketch（CMS）过滤器中元素的计数。
    redisBloomFilter.CF_EXISTS: Count-Min Sketch（CMS）命令，用于检查元素是否存在于 Count-Min Sketch（CMS）过滤器中。
    redisBloomFilter.CF_INSERT: Count-Min Sketch（CMS）命令，用于向 Count-Min Sketch（CMS）过滤器中插入元素。
    redisBloomFilter.CF_INSERTNX: Count-Min Sketch（CMS）命令，用于当元素不存在时向 Count-Min Sketch（CMS）过滤器中插入元素。
    redisBloomFilter.CF_LOADCHUNK: Count-Min Sketch（CMS）命令，用于加载 Count-Min Sketch（CMS）过滤器的数据块。
    redisBloomFilter.CF_SCANDUMP: Count-Min Sketch（CMS）命令，用于以迭代方式获取 Count-Min Sketch（CMS）过滤器的数据块。
    redisBloomFilter.CMS_INCRBY: Count-Min Sketch（CMS）命令，用于对 Count-Min Sketch（CMS）过滤器中的元素进行增量操作。
    redisBloomFilter.CMS_INFO: Count-Min Sketch（CMS）命令，用于获取 Count-Min Sketch（CMS）过滤器的信息。
    redisBloomFilter.CMS_INITBYDIM: Count-Min Sketch（CMS）命令，用于使用指定的宽度和深度初始化 Count-Min Sketch（CMS）过滤器。
    redisBloomFilter.CMS_INITBYPROB: Count-Min Sketch（CMS）命令，用于使用指定的误差率和概率初始化 Count-Min Sketch（CMS）过滤器。
    redisBloomFilter.CMS_MERGE: Count-Min Sketch（CMS）命令，用于将多个 Count-Min Sketch（CMS）过滤器合并到目标过滤器中。
    redisBloomFilter.CMS_QUERY: Count-Min Sketch（CMS）命令，用于查询 Count-Min Sketch（CMS）过滤器中的元素计数。
    redisBloomFilter.TDIGEST_ADD: T-Digest 命令，用于向 T-Digest 数据结构中添加值。
    redisBloomFilter.TDIGEST_INFO: T-Digest 命令，用于获取 T-Digest 数据结构的信息。
    redisBloomFilter.TDIGEST_CREATE: T-Digest 命令，用于创建一个 T-Digest 数据结构。
    redisBloomFilter.TDIGEST_CDF: T-Digest 命令，用于获取 T-Digest 数据结构中小于等于指定值的累积分布函数值。
    redisBloomFilter.TDIGEST_MAX: T-Digest 命令，用于获取 T-Digest 数据结构中的最大值。
    redisBloomFilter.TDIGEST_MERGE: T-Digest 命令，用于将一个 T-Digest 数据结构合并到另一个数据结构中。
    redisBloomFilter.TDIGEST_MIN: T-Digest 命令，用于获取 T-Digest 数据结构中的最小值。
    redisBloomFilter.TDIGEST_QUANTILE: T-Digest 命令，用于获取 T-Digest 数据结构中指定分位数的值。
    redisBloomFilter.TDIGEST_RESET: T-Digest 命令，用于重置 T-Digest 数据结构。
    redisBloomFilter.TOPK_ADD: Top-K 命令，用于向 Top-K 数据结构中添加元素。
    redisBloomFilter.TOPK_INFO: Top-K 命令，用于获取 Top-K 数据结构的信息。
    redisBloomFilter.TOPK_LIST: Top-K 命令，用于获取 Top-K 数据结构
    redisBloomFilter.TOPK_RESERVE: Top-K 命令，用于创建一个 Top-K 数据结构。它将为 Top-K 数据结构分配所需的内存空间。
    redisBloomFilter.TOPK_COUNT: Top-K 命令，用于获取 Top-K 数据结构中指定元素的计数。它返回指定元素在 Top-K 数据结构中的出现次数。
    redisBloomFilter.TOPK_QUERY: Top-K 命令，用于查询 Top-K 数据结构中指定元素的计数和排名。它返回指定元素的计数和在 Top-K 数据结构中的排名信息。
    

五、布隆过滤器的信息：from redisbloom.client import CFInfo

1. CFInfo.size: 获取 Count-Min Sketch（CMS）过滤器的大小，即过滤器使用的内存大小。
2. CFInfo.filterNum: 获取 Count-Min Sketch（CMS）过滤器的数量，即过滤器的个数。
3. CFInfo.insertedNum: 获取 Count-Min Sketch（CMS）过滤器中插入的元素数量。
4. CFInfo.expansionRate: 获取 Count-Min Sketch（CMS）过滤器的扩展率，即过滤器的扩展比例。
5. CFInfo.bucketNum: 获取 Count-Min Sketch（CMS）过滤器的桶数，即过滤器中的桶的数量。
6. CFInfo.bucketSize: 获取 Count-Min Sketch（CMS）过滤器中每个桶的大小。
7. CFInfo.deletedNum: 获取 Count-Min Sketch（CMS）过滤器中已删除的元素数量。
8. CFInfo.maxIteration: 获取 Count-Min Sketch（CMS）过滤器的最大迭代次数，即过滤器进行迭代操作的最大次数。

六、布隆过滤器的信息：from redisbloom.client import BFInfo

1. BFInfo.size: 获取 Bloom 过滤器的大小，即过滤器使用的内存大小。
2. BFInfo.filterNum: 获取 Bloom 过滤器的数量，即过滤器的个数。
3. BFInfo.insertedNum: 获取 Bloom 过滤器中插入的元素数量。
4. BFInfo.expansionRate: 获取 Bloom 过滤器的扩展率，即过滤器的扩展比例。
5. BFInfo.capacity: 获取 Bloom 过滤器的容量，即过滤器可以容纳的最大元素数量。

七、计数器的信息：from redisbloom.client import CMSInfo

1. CMSInfo.count: 获取 Count-Min Sketch（CMS）过滤器中元素的计数。
2. CMSInfo.width: 获取 Count-Min Sketch（CMS）过滤器的宽度，即每个哈希函数的输出位数。
3. CMSInfo.depth: 获取 Count-Min Sketch（CMS）过滤器的深度，即哈希函数的数量。

八、TDigest（Top-K 和分位数）的信息：from redisbloom.client import TDigestInfo

1. TDigestInfo.capacity: 获取 TDigest 的容量，即可以存储的数据点的最大数量。
2. TDigestInfo.compression: 获取 TDigest 的压缩率，即用于控制数据点合并的压缩因子。
3. TDigestInfo.mergedNodes: 获取 TDigest 中已合并的节点数量。
4. TDigestInfo.mergedWeight: 获取 TDigest 中已合并节点的总权重。
5. TDigestInfo.unmergedNodes: 获取 TDigest 中未合并的节点数量。
6. TDigestInfo.totalCompressions: 获取 TDigest 总共进行的压缩次数。
7. TDigestInfo.unmergedWeight: 获取 TDigest 中未合并节点的总权重。

九、Top-K 数据结构的信息：from redisbloom.client import TopKInfo

1. TopKInfo.depth: 获取 Top-K 数据结构的深度，即哈希函数的数量。
2. TopKInfo.width: 获取 Top-K 数据结构的宽度，即每个哈希函数的输出位数。
3. TopKInfo.k: 获取 Top-K 数据结构中保留的最高频率元素的数量。
4. TopKInfo.decay: 获取 Top-K 数据结构的衰减因子，用于控制元素频率的衰减速度。

十、执行 RedisBloom 操作的批量管道：from redisbloom.client import Pipeline，继承redis中的Pipeline

1. pipeline = Pipeline(connection_pool, response_callbacks, transaction, shard_hint)：创建管道对象

   connection_pool：一个 Redis 连接池对象，用于管理与 Redis 服务器的连接。
   response_callbacks：一个可选的回调函数列表，用于处理每个命令的响应结果。
   transaction：一个布尔值，指示是否将命令打包为事务。默认为 False，表示不使用事务。
   shard_hint：一个用于分片的提示值，用于指示哪个 Redis 节点应该处理这些命令。默认为 None，表示不进行分片。
   

2. pipeline.reset(): 重置管道，清除已缓存的命令。
3. pipeline.multi(): 开始一个事务块，将后续的命令添加到事务中。
4. pipeline.execute_command(*args, **kwargs): 执行 Redis 命令，并将其添加到管道中。
5. pipeline.immediate_execute_command(*args, **options): 立即执行 Redis 命令，而不将其添加到管道中。
6. pipeline.pipeline_execute_command(*args, **options): 在管道中执行 Redis 命令。
7. pipeline.raise_first_error(commands, response): 在执行管道中的命令时，如果出现错误，将引发第一个错误。
8. pipeline.annotate_exception(exception, number, command): 为异常添加命令和序号的注释。
9. pipeline.parse_response(connection, command_name, **options): 解析 Redis 响应。
10. pipeline.load_scripts(): 加载 Redis 脚本。
11. pipeline.execute(raise_on_error=True): 执行管道中的所有命令。
12. pipeline.watch(*names): 监视给定的键，以便在执行事务期间检测到键的更改。