python布隆过滤器

① 布隆过滤器的基本原理和使用

工作中遇到一个需求，需要从词库中快速判断某个关键字是否存在，词库大小不超过百万，当时脑子第一反应是用hash表相关数据结构，和同事一交流，同事推荐用布隆过滤器，查询效率不输hashmap，而且非常节省存储空间。经过研究发现布隆过滤器挺好用的，这篇文章来说说三点：
1.什么是布隆过滤器。
2.布隆过滤器基本原理。
3.布隆过滤器的使用方式。

布隆过滤器（Bloom Filter）是1970年由[布隆]提出的。它实际上是一个很长的[二进制]向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都比一般的算法要好的多，缺点是有一定的误识别率和删除困难。

a.下图是一个初始化后的长度为11的布隆过滤器结构，可以看成一个数组，还未放入任何数据，所有位的值都是0。

b.假如有三个hash函数（hash1、hash2、hash3）此时我们添加一个关键字进去，假设我们添加一个字母"a"，通过三个hash函数分别求出2、5、6，于是把下标为2、5、6的值都改为1。

c.此时我们根据字母"a"去布隆过滤器查找，判断a是否存在的流程如下图，由于对a进行三个hash函数取模得到的2、5、6下标的值都是1，说明这个a大概率已经存在了（为什么是大概率呢？因为布隆过滤器是一种概率型数据结构，存在非常小的误判几率，不能判断某个元素一定百分之百存在，所以只能用在允许有少量误判的场景，不能用在需要100%精确判断存在的场景）。
如果使用字母b进行查找，三个hash函数取模得到的是7、8、9或者3、5、6，发现这些下标对应的值都不全部是1，则判定为不存在。

相对于HashMap的优点：
布隆过滤器节省空间，无需存储全部数据，只需要将多个hash函数取模得到的下标对应位置的值改为1即可，无需存储全部数据，是一种极度节省存储空间的数据结构。

相对于HashMap的缺点：
布隆过滤器无法做到100%精确判断，而HashMap可以。布隆过滤器本质上是赌不同的字符串不太可能所有的哈希函数都发生哈希碰撞，虽然有极低的概率发生，但是基本可以把误判率控制在1%以内。

② 布隆过滤器

如果使用哈希表，内存空间需要100亿*64字节=640G(10亿字节（byte）是1G)，空间就爆掉了。此时就轮到布隆过滤器登场了。

布隆过滤器应用场景：黑名单 爬虫去重
布隆过滤器优势：节省内存(30G以内)，查询速度快
布隆过滤器劣势：存在一定失误率

但布隆过滤器的失误率是可以容忍的，一是可以通过设计人为的把失误率控制的很低；二是就算失误了不会误报已经在黑名单里的URL。布隆过滤器只会把正常的URL当成黑名单系统里的，但不会误报已经在黑名单里的URL。形象点说就是“宁可错杀三千不会放过一个”

在讲解布隆过滤器原理之前先讲位图。
位图是bit类型的数组。 int类型4字节即32bit，所以长度100的int类型数组可以看出长度3200的bit数组。假如要找1782位比特，那么在int数组里下标是1782/32，在下标里存的int数字里第几个比特位？即1782%32的计算结果，从而把整型数组操作转换成比特类型数组操作。

布隆过滤器即大位图，假设是长度为m的bit数组，那么占用m/8位字节（Byte）,
URL加黑名单过程：开始时m位比特都是0（白）的状态，该URL通过哈希函数f1得到一个哈希值，然后%m,得到0~m-1上某个位置，将该位置描黑（变成1），再用哈希函数f2得到一个哈希值，再描黑，再用哈希函数f3同样处理（f1、f2、f3是独立的哈希函数），假设一共用了k个哈希函数，那么描黑了k个位置（某个位置重复了就重复了，但一旦描黑就没有描白的时候）完成后可以说该URL加入了位图里。对下一个URL同样处理，用k个哈希函数描黑k个位置……一直做100亿个，位图中有相当多位置被描黑了。
如何查某个URL在不在黑名单里？把待查的URL用K个哈希函数算出对应的哈希值，再把该哈希值%m，把K个位置的状态都拿出来，如果全黑，就说这个URL属于黑名单系统，如果有一个是白，就不属于黑名单系统。如果m很小，100亿个URL之后所有位图都是黑的，那么不论查谁都在黑名单里；如果m取的大一些，失误率就会降低。
但布隆过滤器需要准备多少个bit位和单样本的大小无关。一个URL经过K个哈希函数得到K个哈希值，对m取模后去相应的大比特map中描黑，只要保证哈希函数能接收单样本这种类型的参数就可以了，与样本是64字节还是128字节无关。所以影响失误率的重要参数就是样本量N和位图比特数组长度m。
布隆过滤器三公式： 出处
1.确定m:对于输入的数据量n（这里是100亿）和失误率p（这里是万分之一），布隆过滤器的大小m：m = - (n lnp) / (ln2 ln2)
2.确定K：K假如很少，例如只有一个哈希函数，相当于每个数据只采集了一个特征点，只把一个位置描黑，查的时候也只用一个哈希函数，特征点不够，失误率虽然不至于很高但有一定的量，如果K很大，例如用10万个哈希函数去把10万个位置描黑，m的空间会接近耗尽，查什么URL都是黑的，失误率非常高。需要的哈希函数的个数k：k = ln2 * m/n = 0.7 * m/n
3.因为前两步中公式1公式2都会进行向上取整，所以公式3算出的实际的失误率与比预期失误率要低

布隆过滤器在Hadoop中的应用：Hadoop中的分布式文件系统，是由许多小文件组成的，如何查询一个数据在哪个文件里？首先不可能记录每个小文件的索引，这样做占用空间太大了。所以每个小文件里都搞一个布隆过滤器，当Hadoop想知道某个key在哪个文件里，就查每一个布隆过滤器，文件a的布隆过滤器会说明你这个key在我这个文件里，但可能会有误报；文件c的布隆过滤器会说明你这个key在我这个文件里，但可能会有误报……如果失误率很低，哪怕有几万个分布式文件，最终可能算出来只有3个文件里可能含有这个key。那么就只用把这3个小文件遍历一遍，就知道key在哪个小文件里了。通俗点讲，如果一个文件真的含有key，那么它的布隆过滤器会说这个key属于我；但因为有失误率，可能会发生一个文件不含有这个key，它还是会说这个key属于我；可是这也没关系，多查一遍就可以，反正失误率很低，需要遍历的文件很少。

③ 精通python网络爬虫之网络爬虫学习路线

欲精通Python网络爬虫，必先了解网络爬虫学习路线，本篇经验主要解决这个问题。部分内容参考自书籍《精通Python网络爬虫》。

作者：韦玮

转载请注明出处

随着大数据时代的到来，人们对数据资源的需求越来越多，而爬虫是一种很好的自动采集数据的手段。

那么，如何才能精通Python网络爬虫呢？学习Python网络爬虫的路线应该如何进行呢？在此为大家具体进行介绍。

1、选择一款合适的编程语言

事实上，Python、PHP、JAVA等常见的语言都可以用于编写网络爬虫，你首先需要选择一款合适的编程语言，这些编程语言各有优势，可以根据习惯进行选择。在此笔者推荐使用Python进行爬虫项目的编写，其优点是：简洁、掌握难度低。

2、掌握Python的一些基础爬虫模块

当然，在进行这一步之前，你应当先掌握Python的一些简单语法基础，然后才可以使用Python语言进行爬虫项目的开发。

在掌握了Python的语法基础之后，你需要重点掌握一个Python的关于爬虫开发的基础模块。这些模块有很多可以供你选择，比如urllib、requests等等，只需要精通一个基础模块即可，不必要都精通，因为都是大同小异的，在此推荐的是掌握urllib，当然你可以根据你的习惯进行选择。

3、深入掌握一款合适的表达式

学会了如何爬取网页内容之后，你还需要学会进行信息的提取。事实上，信息的提取你可以通过表达式进行实现，同样，有很多表达式可以供你选择使用，常见的有正则表达式、XPath表达式、BeautifulSoup等，这些表达式你没有必要都精通，同样，精通1-2个，其他的掌握即可，在此建议精通掌握正则表达式以及XPath表达式，其他的了解掌握即可。正则表达式可以处理的数据的范围比较大，简言之，就是能力比较强，XPath只能处理XML格式的数据，有些形式的数据不能处理，但XPath处理数据会比较快。

4、深入掌握抓包分析技术

事实上，很多网站都会做一些反爬措施，即不想让你爬到他的数据。最常见的反爬手段就是对数据进行隐藏处理，这个时候，你就无法直接爬取相关的数据了。作为爬虫方，如果需要在这种情况下获取数据，那么你需要对相应的数据进行抓包分析，然后再根据分析结果进行处理。一般推荐掌握的抓包分析工具是Fiddler，当然你也可以用其他的抓包分析工具，没有特别的要求。

5、精通一款爬虫框架

事实上，当你学习到这一步的时候，你已经入门了。

这个时候，你可能需要深入掌握一款爬虫框架，因为采用框架开发爬虫项目，效率会更加高，并且项目也会更加完善。

同样，你可以有很多爬虫框架进行选择，比如Scrapy、pySpider等等，一样的，你没必要每一种框架都精通，只需要精通一种框架即可，其他框架都是大同小异的，当你深入精通一款框架的时候，其他的框架了解一下事实上你便能轻松使用，在此推荐掌握Scrapy框架，当然你可以根据习惯进行选择。

6、掌握常见的反爬策略与反爬处理策略

反爬，是相对于网站方来说的，对方不想给你爬他站点的数据，所以进行了一些限制，这就是反爬。

反爬处理，是相对于爬虫方来说的，在对方进行了反爬策略之后，你还想爬相应的数据，就需要有相应的攻克手段，这个时候，就需要进行反爬处理。

事实上，反爬以及反爬处理都有一些基本的套路，万变不离其宗，这些后面作者会具体提到，感兴趣的可以关注。

常见的反爬策略主要有：

IP限制

UA限制

Cookie限制

资源随机化存储

动态加载技术

……

对应的反爬处理手段主要有：

IP代理池技术

用户代理池技术

Cookie保存与处理

自动触发技术

抓包分析技术+自动触发技术

……

这些大家在此先有一个基本的思路印象即可，后面都会具体通过实战案例去介绍。

7、掌握PhantomJS、Selenium等工具的使用

有一些站点，通过常规的爬虫很难去进行爬取，这个时候，你需要借助一些工具模块进行，比如PhantomJS、Selenium等，所以，你还需要掌握PhantomJS、Selenium等工具的常规使用方法。

8、掌握分布式爬虫技术与数据去重技术

如果你已经学习或者研究到到了这里，那么恭喜你，相信现在你爬任何网站都已经不是问题了，反爬对你来说也只是一道形同虚设的墙而已了。

但是，如果要爬取的资源非常非常多，靠一个单机爬虫去跑，仍然无法达到你的目的，因为太慢了。

所以，这个时候，你还应当掌握一种技术，就是分布式爬虫技术，分布式爬虫的架构手段有很多，你可以依据真实的服务器集群进行，也可以依据虚拟化的多台服务器进行，你可以采用urllib+redis分布式架构手段，也可以采用Scrapy+redis架构手段，都没关系，关键是，你可以将爬虫任务部署到多台服务器中就OK。

至于数据去重技术，简单来说，目的就是要去除重复数据，如果数据量小，直接采用数据库的数据约束进行实现，如果数据量很大，建议采用布隆过滤器实现数据去重即可，布隆过滤器的实现在Python中也是不难的。

以上是如果你想精通Python网络爬虫的学习研究路线，按照这些步骤学习下去，可以让你的爬虫技术得到非常大的提升。

至于有些朋友问到，使用Windows系统还是Linux系统，其实，没关系的，一般建议学习的时候使用Windows系统进行就行，比较考虑到大部分朋友对该系统比较数据，但是在实际运行爬虫任务的时候，把爬虫部署到Linux系统中运行，这样效率比较高。由于Python的可移植性非常好，所以你在不同的平台中运行一个爬虫，代码基本上不用进行什么修改，只需要学会部署到Linux中即可。所以，这也是为什么说使用Windows系统还是Linux系统进行学习都没多大影响的原因之一。

本篇文章主要是为那些想学习Python网络爬虫，但是又不知道从何学起，怎么学下去的朋友而写的。希望通过本篇文章，可以让你对Python网络爬虫的研究路线有一个清晰的了解，这样，本篇文章的目的就达到了，加油！

本文章由作者韦玮原创，转载请注明出处。

④ 布隆过滤器

[TOC]

通过解决方案：

Java中如将数据存储在内存中，最简单的算法结构是HashMap。通过HashMap判断key是否存在，来判断数据是否存在。通过hash算法查找元素，时间复杂度基本是 O(1) （可能存在hash冲突后转换成链表或红黑树的情况，时间复杂度的影响可以忽略）。

使用HashMap速度很快，存储简单，绝大部分场景可以使用。但是HashMap 占用的空间比较大 ：

为什么出现布隆过滤器：

举例：

如1000万个Integer存储在内存中，占用空间为：4x32x10000000位，即1220兆。如布隆过滤器通过4字节存储（布隆过滤器通过多次hash对数据计算后-->几次hash根据数据量指定，得到多个数据， 占用多个位 ），则占用空间为610M。比原有空间少一半。

个人觉得，此比较在字符等的比较中尤为有效。
一个字符串多个字符，根据编码方式，一个字符两个或三个字节，如10个字符，字符串存储占用20个字节，还有相关字符串相关的类信息的内存占用。
位存储，根据数据量的大小，hash的位数，灵活计算。如4个字节，则是原hashMap占用空间的五分之一。

（1）定义字节向量

先定义一个指定长度的字节数组（字节数组，数组内每个元素的值）。

如长度为8（一个字节大小），默认所有元素值均为0，如下：

（2）计算哈希值

将要写入过滤器的数据，根据一定数量的哈希函数，得到多个哈希值，再依次判断每个哈希值对应的索引。

如使用3个哈希函数，计算得到3个哈希值，判定哈希值对应的字节向量为为1，3，7。

（3）更新字节向量

将计算出的字节向量的索引， 对应的字节向量中的元素值更高为1 （无论之前为0或者为1，均更改为1）。如下：

（1）计算哈希值

将要判断过滤器中是否存在的数据，根据一定数量的哈希函数，得到多个哈希值，再依次判断每个哈希值对应的索引。

如使用3个哈希函数，计算得到3个哈希值，判定哈希值对应的字节向量为为1，3，7。

注意：哈希函数的判断方式和计算索引的方式，需和写入数据时完全一致。

（2）判断是否存在

如原字节数组中，对应1，3，7中存在的元素的值都为1。则判定为此元素 可能存在 ，但凡有一个元素的值不为1，则判定此元素 一定不存在 。

布隆过滤器，主要需实现的目标是， 在指定的数据个数范围内，满足误判率在设定的范围内 ，误判率太高的话，无法起到过滤数据的情况，误判率不能为0。

因此需要计算两个数据来满足 存储数据的个数 和 误判率 ：

使用布隆过滤器的决定性因素之一，就是此算法插入数据和查询数据的速度必须非常快。因此在对数据进行哈希运算的时候， 需选择计算快的哈希算法 。

而且， 写入数据以及查询数据的哈希算法，顺序和算法都需完全一致 。

待完善。。。。。

可以通过google的 guava ，在内存中轻松实现布隆过滤器。

无需手动计算满足字节数组的长度和哈希个数，只需要输入 拟输入数据的个数 和 期望误判率 即可。

不输入期望误判率的情况下，误判率为0.03，即100个非范围内的数据进行校验时，约三个数据会判定为存在。

多次执行，结果一致，根据结果判定：

内存的存储存在局限性，可以使用redis中的bitMap来实现字节数组的存储。

使用redis实现布隆过滤器。需要根据公式，手动计算字节数组的长度和哈希的个数。

实现过程，待完善。。。。。。

⑤ 布隆过滤器和替代算法

布隆过滤器和替代算法：但是布隆过滤器的缺点和优点一样明显。误算率是其中之一。随着存入的元素数量增加，误算率随之增加。但是如果元素数量太少，则使用散列表足矣。

但是包含查找的数据项的数据文件它一定是会返回的，key-value系统中bloom filter返回的数据文件还是需要查看里面的内容才能知道是否存在所需的数据的，这就保证了执行结果的正确性和完整性。

只是多访问一些数据文件而已。在数据量很大key-value系统中，建立统一的B+树索引的代价是非常大的，维护成本也很高，因此综合起来bloom filter的性能是最好的。

缺点：

但是布隆过滤器的缺点和优点一样明显。误算率是其中之一。随着存入的元素数量增加，误算率随之增加。常见的补救办法是建立一个小的白名单，存储那些可能被误判的元素。但是如果元素数量太少，则使用散列表足矣。

另外，一般情况下不能从布隆过滤器中删除元素。我们很容易想到把位列阵变成整数数组，每插入一个元素相应的计数器加1, 这样删除元素时将计数器减掉就可以了。

⑥ 布隆过滤器（Bloom Filter）与比特币

布隆过滤器（Bloom Filter）是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合。它的优点是空间效率和查询时间都比一般的算法要好得多，缺点是有一定的误识别率和删除困难。

如果想要判断一个元素是否在一个集合里，一般想到的是将所有元素保存起来，然后通过比较确定。数组、链表、树等数据结构都是这种思路，它们的时间复杂度为（O(n)、O(logn)）。散列表是一个能够提供更快查询速度的数据结构（时间复杂度为O(1)）。但是随着集合中元素的增加，我们需要的存储空间越来越大，特别是随着大数据的发展，我们越来越不可能将所有的数据都先加载到内存中再进行查找。
这时，我们就可以借助一种新的数据结构，也就是本文的主题：布隆过滤器（Bloom Filter）。
我们使用一段长度为m的二进制位数组，再使用k个哈希函数，将一个值进行k次哈希，得到k个索引，并将对应的位置设置为1。

布隆过滤器主要提供两种方法：Add和Test。
Add：通过哈希函数计算，得到k个索引，并将其对应的二进制位设置为1。
Test：通过哈希函数计算，得到k个索引，判断如果任意位置上的二进制都为0，则表示该值一定不在集合中；但是如果所有位置上的二进制都为1，却并不能表示该值一定在集合中，这被称为假阳性，或是判断错误。
可以通过增大数组的长度m，以及增加哈希函数的数量k来降低假阳性的概率。

时间复杂度
由于需要计算k次的哈希，需要的时间复杂度为O(k)，而计算出对应的索引后，可以进行直接地址访问，需要的时间复杂度为O(1)，所以总的时间复杂度为O(k)。

空间复杂度
由于需要长度为m的二进制数据，所以空间复杂度为O(m)，但是由于数据的基本单位是位，假设为了处理100万条数据，为了降低假阳性的概率，我们使用长度为1000万的二进制数组，所需的内存空间为10,000,000/8/1024/1024=1.2M内存空间。

优点

缺点

⑦ BloomFilter详解（布隆过滤器）

从上式中可以看出，当m增大或n减小时，都会使得误判率减小，这也符合直觉。

现在计算对于给定的m和n，k为何值时可以使得误判率最低。设误判率为k的函数为：

这说明了若想保持某固定误判率不变，布隆过滤器的bit数m与被add的元素数n应该是线性同步增加的。

三 如何设计bloomfilter

此概率为某bit位在插入n个元素后未被置位的概率。因此，想保持错误率低，布隆过滤器的空间使用率需为50%。

bloomfilter的各个参数的错误率

公式推完了，大家可以看看，里面的数学公式基本用到了指数函数 对数函数 微积分求导法则 概率论的知识，大家可以补充看下课本。

个人介绍：杜宝坤，京东联邦学习从0到1构建者，带领团队构建了京东的联邦学习解决方案，实现了电商营销领域支持超大规模的工业化联邦学习解决方案，支持超大规模样本PSI隐私对齐、安全的树模型与神经网络模型等众多模型支持，并且实现了广告侧等业务领域的落地，开创了新的业务增长点，产生了显着的业务经济效益。

个人喜欢研究技术。基于从全链路思考与决策技术规划的考量，研究的领域比较多，从架构、数据到算法与算法框架均有涉及。欢迎喜欢技术的同学和我交流，邮箱： [email protected]

⑧ 如何用python写布隆过滤器

下面的是网络上找到的python的布隆过滤器的实现.

#!/usr/local/bin/python2.7
#coding=gbk
'''
Createdon2012-11-7

@author:palydawn
'''
importcmath
fromBitVectorimportBitVector

classBloomFilter(object):
def__init__(self,error_rate,elementNum):
#计算所需要的bit数
self.bit_num=-1*elementNum*cmath.log(error_rate)/(cmath.log(2.0)*cmath.log(2.0))

#四字节对齐
self.bit_num=self.align_4byte(self.bit_num.real)

#分配内存
self.bit_array=BitVector(size=self.bit_num)

#计算hash函数个数
self.hash_num=cmath.log(2)*self.bit_num/elementNum

self.hash_num=self.hash_num.real

#向上取整
self.hash_num=int(self.hash_num)+1

#产生hash函数种子
self.hash_seeds=self.generate_hashseeds(self.hash_num)

definsert_element(self,element):
forseedinself.hash_seeds:
hash_val=self.hash_element(element,seed)
#取绝对值
hash_val=abs(hash_val)
#取模，防越界
hash_val=hash_val%self.bit_num
#设置相应的比特位
self.bit_array[hash_val]=1

#检查元素是否存在，存在返回true，否则返回false
defis_element_exist(self,element):
forseedinself.hash_seeds:
hash_val=self.hash_element(element,seed)
#取绝对值
hash_val=abs(hash_val)
#取模，防越界
hash_val=hash_val%self.bit_num

#查看值
ifself.bit_array[hash_val]==0:
returnFalse
returnTrue

#内存对齐
defalign_4byte(self,bit_num):
num=int(bit_num/32)
num=32*(num+1)
returnnum

#产生hash函数种子,hash_num个素数
defgenerate_hashseeds(self,hash_num):
count=0
#连续两个种子的最小差值
gap=50
#初始化hash种子为0
hash_seeds=[]
forindexinxrange(hash_num):
hash_seeds.append(0)
forindexinxrange(10,10000):
max_num=int(cmath.sqrt(1.0*index).real)
flag=1
fornuminxrange(2,max_num):
ifindex%num==0:
flag=0
break

ifflag==1:
#连续两个hash种子的差值要大才行
ifcount>0and(index-hash_seeds[count-1])<gap:
continue
hash_seeds[count]=index
count=count+1

ifcount==hash_num:
break
returnhash_seeds

defhash_element(self,element,seed):
hash_val=1
forchinstr(element):
chval=ord(ch)
hash_val=hash_val*seed+chval
returnhash_val
'''
#测试代码
bf=BloomFilter(0.001,1000000)
element='palydawn'
bf.insert_element(element)
printbf.is_element_exist('palydawn')'''

#其中使用了BitVector库，python本身的二进制操作看起来很麻烦，这个就简单多了

如果解决了您的问题请采纳！
如果未解决请继续追问