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

#coding=gbk

'''

Created on 2012-11-7

@author: palydawn

'''

import cmath

from BitVector import BitVector

class BloomFilter(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)

    def insert_element(self, element):

        for seed in self.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 

    def is_element_exist(self, element):

        for seed in self.hash_seeds:

            hash_val = self.hash_element(element, seed)

            #取绝对值

            hash_val = abs(hash_val)

            #取模，防越界

            hash_val = hash_val % self.bit_num

            #查看值

            if self.bit_array[hash_val] == 0:

                return False

        return True

    #内存对齐    

    def align_4byte(self, bit_num):

        num = int(bit_num / 32)

        num = 32 * (num + 1)

        return num

    #产生hash函数种子,hash_num个素数

    def generate_hashseeds(self, hash_num):

        count = 0

        #连续两个种子的最小差值

        gap = 50

        #初始化hash种子为0

        hash_seeds = []

        for index in xrange(hash_num):

            hash_seeds.append(0)

        for index in xrange(10, 10000):

            max_num = int(cmath.sqrt(1.0 * index).real)

            flag = 1

            for num in xrange(2, max_num):

                if index % num == 0:

                    flag = 0

                    break

            if flag == 1:

                #连续两个hash种子的差值要大才行

                if count > 0 and (index - hash_seeds[count - 1]) < gap:

                    continue

                hash_seeds[count] = index

                count = count + 1

            if count == hash_num:

                break

        return hash_seeds

    def hash_element(self, element, seed):

        hash_val = 1

        for ch in str(element):

            chval = ord(ch)

            hash_val = hash_val * seed + chval

        return hash_val

'''

#测试代码

bf = BloomFilter(0.001, 1000000)

element = 'palydawn'

bf.insert_element(element)

print bf.is_element_exist('palydawn')'''

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

如果解决了您的问题请采纳！

如果未解决请继续追问

from PyQt5.QtGui import *

from PyQt5.QtCore import *

from PyQt5.QtWidgets import *

import sys

class EventFilter(QDialog):

def init (self, parent=None):

super(EventFilter, self). init (parent)

self.setWindowTitle("事件过滤器")

if name == ' main ':

app = QApplication(sys.argv)

dialog = EventFilter()

dialog.show()

sys.exit(app.exec_())

filter 方法可以返回原始对象的子集.

例如，我们想提取分组内的和大于 3 的所有分组的元素

filter 的参数必须是一个函数，函数参数是每个分组，并且返回 True 或 False

例如，提取元素个数大于 2 的分组

另外，我们也可以过滤掉不满足条件的组，而是返回一个类似索引对象。在这个对象中，没有通过的分组的元素被 NaN 填充

对于具有多列的 DataFrames ，过滤器应明确指定一列作为过滤条件

在进行聚合或转换时，你可能想对每个分组调用一个实例方法，例如

但是，如果需要传递额外的参数时，它会变得很冗长。我们可以直接使用分派到组对象上的方法

实际上这生成了一个函数包装器，在调用时，它接受所有传递的参数，并在每个分组上进行调用。

然后，这个结果可以和 agg 和 transform 结合在一起使用

在上面的例子中，我们按照年份分组，然后对每个分组中使用 fillna 补缺失值

nlargest 和 nsmallest 可以在 Series 类型的 groupby 上使用

对分组数据的某些操作可能并不适合聚合或转换。或者说，你可能只是想让 GroupBy 来推断如何合并结果

我们可以使用 apply 函数，例如

改变返回结果的维度

在 Series 上使用 apply 类似

对于之前的示例数据

假设，我们想按 A 分组并计算组内的标准差，但是 B 列的数据我们并不关心。

如果我们的函数不能应用于某些列，则会隐式的删除这些列，所以

直接计算标准差并不会报错

可以使用分类变量进行分组，分组的顺序会按照分类变量的顺序

可以使用 pd.Grouper 控制分组，对于如下数据

可以按照一定的频率对特定列进行分组，就像重抽样一样

可以分别对列或索引进行分组

类似于 Series 和 DataFrame ，可以使用 head 和 tail 获取分组前后几行

在 Series 或 DataFrame 中可以使用 nth() 来获取第 n 个元素，也可以用于获取每个分组的某一行

如果你要选择非空项，可以使用关键字参数 dropna ，如果是 DataFrame ，需要指定为 any 或 all (类似于 DataFrame.dropna(how='any|all') )

与其他方法一样，使用 as_index=False 分组名将不会作为索引

你也可以传入一个整数列表，一次性选取多行

使用 cumcount 方法，可以查看每行在分组中出现的顺序

可以使用 ngroup() 查看分组的顺序，该顺序与 cumcount 的顺序相反。

注意 ：该顺序与迭代时的分组顺序一样，并不是第一次观测到的顺序