用Python实现一个大数据搜索引擎

搜索是大数据领域里常见的需求。Splunk和ELK分别是该领域在非开源和开源领域里的***。本文利用很少的Python代码实现了一个基本的数据搜索功能，试图让大家理解大数据搜索的基本原理。

发展壮大离不开广大客户长期以来的信赖与支持，我们将始终秉承“诚信为本、服务至上”的服务理念，坚持“二合一”的优良服务模式，真诚服务每家企业，认真做好每个细节，不断完善自我，成就企业，实现共赢。行业涉及成都不锈钢雕塑等，在成都网站建设、成都全网营销推广、WAP手机网站、VI设计、软件开发等项目上具有丰富的设计经验。

布隆过滤器 （Bloom Filter）

***步我们先要实现一个布隆过滤器。

布隆过滤器是大数据领域的一个常见算法，它的目的是过滤掉那些不是目标的元素。也就是说如果一个要搜索的词并不存在与我的数据中，那么它可以以很快的速度返回目标不存在。

让我们看看以下布隆过滤器的代码：

 
 
 
 
    
  
  
  
  
  1. class Bloomfilter(object): 
    2.   
  
  
  
  2.     """ 
    3.   
  
  
  
  3.     A Bloom filter is a probabilistic data-structure that trades space for accuracy 
    4.   
  
  
  
  4.     when determining if a value is in a set.  It can tell you if a value was possibly 
    5.   
  
  
  
  5.     added, or if it was definitely not added, but it can't tell you for certain that 
    6.   
  
  
  
  6.     it was added. 
    7.   
  
  
  
  7.     """ 
    8.   
  
  
  
  8.     def __init__(self, size): 
    9.   
  
  
  
  9.         """Setup the BF with the appropriate size""" 
    10.   
  
  
  
  10.         self.values = [False] * size 
    11.   
  
  
  
  11.         self.size = size 
    12.   
  
  
  
  12.   
    13.   
  
  
  
  13.     def hash_value(self, value): 
    14.   
  
  
  
  14.         """Hash the value provided and scale it to fit the BF size""" 
    15.   
  
  
  
  15.         return hash(value) % self.size 
    16.   
  
  
  
  16.   
    17.   
  
  
  
  17.     def add_value(self, value): 
    18.   
  
  
  
  18.         """Add a value to the BF""" 
    19.   
  
  
  
  19.         h = self.hash_value(value) 
    20.   
  
  
  
  20.         self.values[h] = True 
    21.   
  
  
  
  21.   
    22.   
  
  
  
  22.     def might_contain(self, value): 
    23.   
  
  
  
  23.         """Check if the value might be in the BF""" 
    24.   
  
  
  
  24.         h = self.hash_value(value) 
    25.   
  
  
  
  25.         return self.values[h] 
    26.   
  
  
  
  26.   
    27.   
  
  
  
  27.     def print_contents(self): 
    28.   
  
  
  
  28.         """Dump the contents of the BF for debugging purposes""" 
    29.   
  
  
  
  29.         print self.values 
    30.
  • 基本的数据结构是个数组（实际上是个位图，用1/0来记录数据是否存在），初始化是没有任何内容，所以全部置False。实际的使用当中，该数组的长度是非常大的，以保证效率。
  • 利用哈希算法来决定数据应该存在哪一位，也就是数组的索引
  • 当一个数据被加入到布隆过滤器的时候，计算它的哈希值然后把相应的位置为True
  • 当检查一个数据是否已经存在或者说被索引过的时候，只要检查对应的哈希值所在的位的True／Fasle

看到这里，大家应该可以看出，如果布隆过滤器返回False，那么数据一定是没有索引过的，然而如果返回True，那也不能说数据一定就已经被索引过。在搜索过程中使用布隆过滤器可以使得很多没有***的搜索提前返回来提高效率。

我们看看这段 code是如何运行的：

 
 
 
 
    
  
  
  
  
  1. bf = Bloomfilter(10) 
    2.   
  
  
  
  2. bf.add_value('dog') 
    3.   
  
  
  
  3. bf.add_value('fish') 
    4.   
  
  
  
  4. bf.add_value('cat') 
    5.   
  
  
  
  5. bf.print_contents() 
    6.   
  
  
  
  6. bf.add_value('bird') 
    7.   
  
  
  
  7. bf.print_contents() 
    8.   
  
  
  
  8. # Note: contents are unchanged after adding bird - it collides 
    9.   
  
  
  
  9. for term in ['dog', 'fish', 'cat', 'bird', 'duck', 'emu']: 
    10.   
  
  
  
  10.     print '{}: {} {}'.format(term, bf.hash_value(term), bf.might_contain(term)) 
    11.

结果：

 
 
 
 
    
  
  
  
  
  1. [False, False, False, False, True, True, False, False, False, True] 
    2.   
  
  
  
  2. [False, False, False, False, True, True, False, False, False, True] 
    3.   
  
  
  
  3. dog: 5 True 
    4.   
  
  
  
  4. fish: 4 True 
    5.   
  
  
  
  5. cat: 9 True 
    6.   
  
  
  
  6. bird: 9 True 
    7.   
  
  
  
  7. duck: 5 True 
    8.   
  
  
  
  8. emu: 8 False 
    9.

首先创建了一个容量为10的的布隆过滤器

然后分别加入 ‘dog’，‘fish’，‘cat’三个对象，这时的布隆过滤器的内容如下：

然后加入‘bird’对象，布隆过滤器的内容并没有改变，因为‘bird’和‘fish’恰好拥有相同的哈希。

***我们检查一堆对象（’dog’, ‘fish’, ‘cat’, ‘bird’, ‘duck’, ’emu’）是不是已经被索引了。结果发现‘duck’返回True，2而‘emu’返回False。因为‘duck’的哈希恰好和‘dog’是一样的。

分词

下面一步我们要实现分词。 分词的目的是要把我们的文本数据分割成可搜索的最小单元，也就是词。这里我们主要针对英语，因为中文的分词涉及到自然语言处理，比较复杂，而英文基本只要用标点符号就好了。

下面我们看看分词的代码：

 
 
 
 
    
  
  
  
  
  1. def major_segments(s): 
    2.   
  
  
  
  2.     """ 
    3.   
  
  
  
  3.     Perform major segmenting on a string.  Split the string by all of the major 
    4.   
  
  
  
  4.     breaks, and return the set of everything found.  The breaks in this implementation 
    5.   
  
  
  
  5.     are single characters, but in Splunk proper they can be multiple characters. 
    6.   
  
  
  
  6.     A set is used because ordering doesn't matter, and duplicates are bad. 
    7.   
  
  
  
  7.     """ 
    8.   
  
  
  
  8.     major_breaks = ' ' 
    9.   
  
  
  
  9.     last = -1 
    10.   
  
  
  
  10.     results = set() 
    11.   
  
  
  
  11.   
    12.   
  
  
  
  12.     # enumerate() will give us (0, s[0]), (1, s[1]), ... 
    13.   
  
  
  
  13.     for idx, ch in enumerate(s): 
    14.   
  
  
  
  14.         if ch in major_breaks: 
    15.   
  
  
  
  15.             segment = s[last+1:idx] 
    16.   
  
  
  
  16.             results.add(segment) 
    17.   
  
  
  
  17.   
    18.   
  
  
  
  18.             last = idx 
    19.   
  
  
  
  19.   
    20.   
  
  
  
  20.     # The last character may not be a break so always capture 
    21.   
  
  
  
  21.     # the last segment (which may end up being "", but yolo)     
    22.   
  
  
  
  22.     segment = s[last+1:] 
    23.   
  
  
  
  23.     results.add(segment) 
    24.   
  
  
  
  24.   
    25.   
  
  
  
  25.     return results 
    26.

主要分割

主要分割使用空格来分词，实际的分词逻辑中，还会有其它的分隔符。例如Splunk的缺省分割符包括以下这些，用户也可以定义自己的分割符。

] < >( ) { } | ! ; , ‘ ” * \n \r \s \t & ? + %21 %26 %2526 %3B %7C %20 %2B %3D — %2520 %5D %5B %3A %0A %2C %28 %29

 
 
 
 
    
  
  
  
  
  1. def minor_segments(s): 
    2.   
  
  
  
  2.     """ 
    3.   
  
  
  
  3.     Perform minor segmenting on a string.  This is like major 
    4.   
  
  
  
  4.     segmenting, except it also captures from the start of the 
    5.   
  
  
  
  5.     input to each break. 
    6.   
  
  
  
  6.     """ 
    7.   
  
  
  
  7.     minor_breaks = '_.' 
    8.   
  
  
  
  8.     last = -1 
    9.   
  
  
  
  9.     results = set() 
    10.   
  
  
  
  10.   
    11.   
  
  
  
  11.     for idx, ch in enumerate(s): 
    12.   
  
  
  
  12.         if ch in minor_breaks: 
    13.   
  
  
  
  13.             segment = s[last+1:idx] 
    14.   
  
  
  
  14.             results.add(segment) 
    15.   
  
  
  
  15.   
    16.   
  
  
  
  16.             segment = s[:idx] 
    17.   
  
  
  
  17.             results.add(segment) 
    18.   
  
  
  
  18.   
    19.   
  
  
  
  19.             last = idx 
    20.   
  
  
  
  20.   
    21.   
  
  
  
  21.     segment = s[last+1:] 
    22.   
  
  
  
  22.     results.add(segment) 
    23.   
  
  
  
  23.     results.add(s) 
    24.   
  
  
  
  24.   
    25.   
  
  
  
  25.     return results 
    26.

次要分割

次要分割和主要分割的逻辑类似，只是还会把从开始部分到当前分割的结果加入。例如“1.2.3.4”的次要分割会有1，2，3，4，1.2，1.2.3

 
 
 
 
    
  
  
  
  
  1. def segments(event): 
    2.   
  
  
  
  2.     """Simple wrapper around major_segments / minor_segments""" 
    3.   
  
  
  
  3.     results = set() 
    4.   
  
  
  
  4.     for major in major_segments(event): 
    5.   
  
  
  
  5.         for minor in minor_segments(major): 
    6.   
  
  
  
  6.             results.add(minor) 
    7.   
  
  
  
  7.     return results 
    8.

分词的逻辑就是对文本先进行主要分割，对每一个主要分割在进行次要分割。然后把所有分出来的词返回。

我们看看这段 code是如何运行的：

 
 
 
 
    
  
  
  
  
  1. for term in segments('src_ip = 1.2.3.4'): 
    2.   
  
  
  
  2.         print term 
    3.  
 
 
 
 
 
 
 
    
  
  
  
  
  1. src 
    2.   
  
  
  
  2. 1.2 
    3.   
  
  
  
  3. 1.2.3.4 
    4.   
  
  
  
  4. src_ip 
    5.   
  
  
  
  5. 3 
    6.   
  
  
  
  6. 1 
    7.   
  
  
  
  7. 1.2.3 
    8.   
  
  
  
  8. ip 
    9.   
  
  
  
  9. 2 
    10.   
  
  
  
  10. = 
    11.   
  
  
  
  11. 4 
    12.

搜索

好了，有个分词和布隆过滤器这两个利器的支撑后，我们就可以来实现搜索的功能了。

上代码：

 
 
 
 
    
  
  
  
  
  1. class Splunk(object): 
    2.   
  
  
  
  2.     def __init__(self): 
    3.   
  
  
  
  3.         self.bf = Bloomfilter(64) 
    4.   
  
  
  
  4.         self.terms = {}  # Dictionary of term to set of events 
    5.   
  
  
  
  5.         self.events = [] 
    6.   
  
  
  
  6.      
    7.   
  
  
  
  7.     def add_event(self, event): 
    8.   
  
  
  
  8.         """Adds an event to this object""" 
    9.   
  
  
  
  9.   
    10.   
  
  
  
  10.         # Generate a unique ID for the event, and save it 
    11.   
  
  
  
  11.         event_id = len(self.events) 
    12.   
  
  
  
  12.         self.events.append(event) 
    13.   
  
  
  
  13.   
    14.   
  
  
  
  14.         # Add each term to the bloomfilter, and track the event by each term 
    15.   
  
  
  
  15.         for term in segments(event): 
    16.   
  
  
  
  16.             self.bf.add_value(term) 
    17.   
  
  
  
  17.   
    18.   
  
  
  
  18.             if term not in self.terms: 
    19.   
  
  
  
  19.                 self.terms[term] = set() 
    20.   
  
  
  
  20.             self.terms[term].add(event_id) 
    21.   
  
  
  
  21.   
    22.   
  
  
  
  22.     def search(self, term): 
    23.   
  
  
  
  23.         """Search for a single term, and yield all the events that contain it""" 
    24.   
  
  
  
  24.          
    25.   
  
  
  
  25.         # In Splunk this runs in O(1), and is likely to be in filesystem cache (memory) 
    26.   
  
  
  
  26.         if not self.bf.might_contain(term): 
    27.   
  
  
  
  27.             return 
    28.   
  
  
  
  28.   
    29.   
  
  
  
  29.         # In Splunk this probably runs in O(log N) where N is the number of terms in the tsidx 
    30.   
  
  
  
  30.         if term not in self.terms: 
    31.   
  
  
  
  31.             return 
    32.   
  
  
  
  32.   
    33.   
  
  
  
  33.         for event_id in sorted(self.terms[term]): 
    34.   
  
  
  
  34.             yield self.events[event_id] 
    35.
  • Splunk代表一个拥有搜索功能的索引集合
  • 每一个集合中包含一个布隆过滤器，一个倒排词表（字典），和一个存储所有事件的数组
  • 当一个事件被加入到索引的时候，会做以下的逻辑
    • 为每一个事件生成一个unqie id，这里就是序号
    • 对事件进行分词，把每一个词加入到倒排词表，也就是每一个词对应的事件的id的映射结构，注意，一个词可能对应多个事件，所以倒排表的的值是一个Set。倒排表是绝大部分搜索引擎的核心功能。
  • 当一个词被搜索的时候，会做以下的逻辑
    • 检查布隆过滤器，如果为假，直接返回
    • 检查词表，如果被搜索单词不在词表中，直接返回
    • 在倒排表中找到所有对应的事件id，然后返回事件的内容

我们运行下看看把：

 
 
 
 
    
  
  
  
  
  1. s = Splunk() 
    2.   
  
  
  
  2. s.add_event('src_ip = 1.2.3.4') 
    3.   
  
  
  
  3. s.add_event('src_ip = 5.6.7.8') 
    4.   
  
  
  
  4. s.add_event('dst_ip = 1.2.3.4') 
    5.   
  
  
  
  5.   
    6.   
  
  
  
  6. for event in s.search('1.2.3.4'): 
    7.   
  
  
  
  7.     print event 
    8.   
  
  
  
  8. print '-' 
    9.   
  
  
  
  9. for event in s.search('src_ip'): 
    10.   
  
  
  
  10.     print event 
    11.   
  
  
  
  11. print '-' 
    12.   
  
  
  
  12. for event in s.search('ip'): 
    13.   
  
  
  
  13.     print event 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15. src_ip = 1.2.3.4 
    16.   
  
  
  
  16. dst_ip = 1.2.3.4 
    17.   
  
  
  
  17. - 
    18.   
  
  
  
  18. src_ip = 1.2.3.4 
    19.   
  
  
  
  19. src_ip = 5.6.7.8 
    20.   
  
  
  
  20. - 
    21.   
  
  
  
  21. src_ip = 1.2.3.4 
    22.   
  
  
  
  22. src_ip = 5.6.7.8 
    23.   
  
  
  
  23. dst_ip = 1.2.3.4 
    24.

是不是很赞！

更复杂的搜索

更进一步，在搜索过程中，我们想用And和Or来实现更复杂的搜索逻辑。

上代码：

 
 
 
 
    
  
  
  
  
  1. class SplunkM(object): 
    2.   
  
  
  
  2.     def __init__(self): 
    3.   
  
  
  
  3.         self.bf = Bloomfilter(64) 
    4.   
  
  
  
  4.         self.terms = {}  # Dictionary of term to set of events 
    5.   
  
  
  
  5.         self.events = [] 
    6.   
  
  
  
  6.      
    7.   
  
  
  
  7.     def add_event(self, event): 
    8.   
  
  
  
  8.         """Adds an event to this object""" 
    9.   
  
  
  
  9.   
    10.   
  
  
  
  10.         # Generate a unique ID for the event, and save it 
    11.   
  
  
  
  11.         event_id = len(self.events) 
    12.   
  
  
  
  12.         self.events.append(event) 
    13.   
  
  
  
  13.   
    14.   
  
  
  
  14.         # Add each term to the bloomfilter, and track the event by each term 
    15.   
  
  
  
  15.         for term in segments(event): 
    16.   
  
  
  
  16.             self.bf.add_value(term) 
    17.   
  
  
  
  17.             if term not in self.terms: 
    18.   
  
  
  
  18.                 self.terms[term] = set() 
    19.   
  
  
  
  19.              
    20.   
  
  
  
  20.             self.terms[term].add(event_id) 
    21.   
  
  
  
  21.   
    22.   
  
  
  
  22.     def search_all(self, terms): 
    23.   
  
  
  
  23.         """Search for an AND of all terms""" 
    24.   
  
  
  
  24.   
    25.   
  
  
  
  25.         # Start with the universe of all events... 
    26.   
  
  
  
  26.         results = set(range(len(self.events))) 
    27.   
  
  
  
  27.   
    28.   
  
  
  
  28.         for term in terms: 
    29.   
  
  
  
  29.             # If a term isn't present at all then we can stop looking 
    30.   
  
  
  
  30.             if not self.bf.might_contain(term): 
    31.   
  
  
  
  31.                 return 
    32.   
  
  
  
  32.             if term not in self.terms: 
    33.   
  
  
  
  33.                 return 
    34.   
  
  
  
  34.   
    35.   
  
  
  
  35.             # Drop events that don't match from our results 
    36.   
  
  
  
  36.             results = results.intersection(self.terms[term]) 
    37.   
  
  
  
  37.   
    38.   
  
  
  
  38.         for event_id in sorted(results): 
    39.   
  
  
  
  39.             yield self.events[event_id] 
    40.   
  
  
  
  40.   
    41.   
  
  
  
  41.   
    42.   
  
  
  
  42.     def search_any(self, terms): 
    43.   
  
  
  
  43.         """Search for an OR of all terms""" 
    44.   
  
  
  
  44.         results = set() 
    45.   
  
  
  
  45.   
    46.   
  
  
  
  46.         for term in terms: 
    47.   
  
  
  
  47.             # If a term isn't present, we skip it, but don't stop 
    48.   
  
  
  
  48.             if not self.bf.might_contain(term): 
    49.   
  
  
  
  49.                 continue 
    50.   
  
  
  
  50.             if term not in self.terms: 
    51.   
  
  
  
  51.                 continue 
    52.   
  
  
  
  52.   
    53.   
  
  
  
  53.             # Add these events to our results 
    54.   
  
  
  
  54.             results = results.union(self.terms[term]) 
    55.   
  
  
  
  55.   
    56.   
  
  
  
  56.         for event_id in sorted(results): 
    57.   
  
  
  
  57.             yield self.events[event_id] 
    58.

利用Python集合的intersection和union操作，可以很方便的支持And（求交集）和Or（求合集）的操作。

运行结果如下：

 
 
 
 
    
  
  
  
  
  1. s = SplunkM() 
    2.   
  
  
  
  2. s.add_event('src_ip = 1.2.3.4') 
    3.   
  
  
  
  3. s.add_event('src_ip = 5.6.7.8') 
    4.   
  
  
  
  4. s.add_event('dst_ip = 1.2.3.4') 
    5.   
  
  
  
  5.   
    6.   
  
  
  
  6. for event in s.search_all(['src_ip', '5.6']): 
    7.   
  
  
  
  7.     print event 
    8.   
  
  
  
  8. print '-' 
    9.   
  
  
  
  9. for event in s.search_any(['src_ip', 'dst_ip']): 
    10.   
  
  
  
  10.     print event 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12. src_ip = 5.6.7.8 
    13.   
  
  
  
  13. - 
    14.   
  
  
  
  14. src_ip = 1.2.3.4 
    15.   
  
  
  
  15. src_ip = 5.6.7.8 
    16.   
  
  
  
  16. dst_ip = 1.2.3.4 
    17.

分享文章：用Python实现一个大数据搜索引擎
网站URL：http://www.shufengxianlan.com/qtweb/news24/33774.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

虚拟主机知识

同城分类信息

防护网厂　　 　成都谷歌推广　　 　自适应网站　　 　内江做网站　　 　成都网站推广　　 　成都橡塑保温板　　 　定制网站　　 　成都网站建设　　 　成都康明斯发电机　　 　网络推广公司　　 　护栏钻孔机　　 　成都封阳台　　 　江油网站建设　　 　成都小谭网创广告　　 　瑞杰管理　　 　成都网站制作　　 　成都定制网站　　 　腾讯云香港免备案空间　　 　什邡网站建设　　 　泽君科技