当前位置:   article > 正文

深入浅出:使用Python构建一个微型搜索引擎从零开始!_python 自建搜索引擎

python 自建搜索引擎

第一部分:引言与基础知识

在信息时代,搜索引擎已经成为我们生活中不可或缺的一部分。无论是搜索烹饪食谱、学习资料还是最新的新闻,搜索引擎都在其中发挥了重要的作用。那么,搜索引擎是如何工作的呢?

本文将指导你使用Python从零开始构建一个微型搜索引擎。我们将首先创建一个简单的爬虫来抓取网页内容,然后使用这些内容构建一个反向索引,最后实现一个简单的搜索算法来查找相关内容。

1. 什么是爬虫?

爬虫,也称为网络爬虫或网络机器人,是一个自动化程序,用于浏览互联网并下载网页内容。简单来说,它们“爬”遍网络并抓取我们需要的信息。

2. 什么是反向索引?

反向索引是搜索引擎用来查找相关网页的核心数据结构。它是一个“词项到文档”的映射,可以快速地查找包含特定词项的所有文档。


开始构建我们的爬虫

使用Python的requests库,我们可以轻松地下载网页内容。

import requests

def get_webpage(url):
    try:
        response = requests.get(url)
        if response.status_code == 200:
            return response.text
    except requests.RequestException as e:
        print(e)
    return None
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

这是一个非常简单的爬虫,它接收一个URL并尝试获取该URL的内容。如果请求成功(返回状态码为200),则返回网页内容;否则返回None

接下来,我们需要解析这些网页以提取我们感兴趣的信息。为此,我们将使用BeautifulSoup库。

from bs4 import BeautifulSoup

def extract_links_from_page(html_content):
    soup = BeautifulSoup(html_content, 'html.parser')
    links = set()

    for anchor in soup.find_all('a', href=True):
        links.add(anchor['href'])

    return links
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

这个函数接收HTML内容并返回在页面上找到的所有链接。

现在我们已经有了下载网页和提取链接的基本功能,接下来我们要使我们的爬虫能够递归地爬取链接。为此,我们将使用一个队列来跟踪要爬取的URLs。

from collections import deque

def simple_crawler(start_url, limit=50):
    visited = set()
    to_visit = deque()
    to_visit.append(start_url)

    while to_visit and len(visited) < limit:
        current_url = to_visit.popleft()
        if current_url not in visited:
            print(f"Crawling: {current_url}")
            content = get_webpage(current_url)
            if content:
                visited.add(current_url)
                for link in extract_links_from_page(content):
                    to_visit.append(link)
    return visited
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

这个简单的爬虫从给定的起始URL开始,并递归地爬取链接,直到达到指定的限制或没有更多的链接可以爬取为止。


好的,我们现在有了一个可以工作的简单爬虫,但为了构建我们的搜索引擎,我们还需要其他组件。在下一部分,我们将介绍如何创建一个反向索引。

第二部分:构建反向索引

反向索引是搜索引擎的核心组件,它能够快速地找到包含特定词语的文档。为了实现这一点,我们需要将每个单词与出现它的文档相关联。

3. 文本处理

在创建反向索引之前,我们需要处理网页内容,将其转化为一系列的词项。首先,我们要清理文本。

import re

def clean_text(text):
    return re.sub(r'\W+', ' ', text.lower())
  • 1
  • 2
  • 3
  • 4

这个函数使用正则表达式移除所有非单词字符,并将文本转化为小写。

然后,我们可以将清理后的文本划分为单词。

def tokenize(text):
    return clean_text(text).split()
  • 1
  • 2

4. 构建反向索引

现在我们可以使用上述方法处理网页内容并创建反向索引了。

from collections import defaultdict

def build_reverse_index(crawled_data):
    index = defaultdict(set)
    for url, content in crawled_data.items():
        for word in tokenize(content):
            index[word].add(url)
    return index
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

crawled_data是一个字典,其中URLs是键,相应的网页内容是值。反向索引是另一个字典,其中单词是键,与之相关的URL集合是值。


5. 搜索查询

有了反向索引,我们可以轻松地实现一个简单的搜索函数。

def search(query, index):
    words = tokenize(query)
    results = set()

    for word in words:
        if word in index:
            if not results:
                results = index[word]
            else:
                results.intersection_update(index[word])

    return results
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

此函数接收一个查询和一个反向索引,然后返回与查询相关的URL集合。


为了完整性,我们现在需要将我们的爬虫、文本处理方法和搜索方法组合起来,创建一个简单的搜索引擎。

def mini_search_engine(start_url, limit=50):
    crawled_data = {}
    urls = simple_crawler(start_url, limit)
    for url in urls:
        content = get_webpage(url)
        if content:
            crawled_data[url] = content

    index = build_reverse_index(crawled_data)

    while True:
        query = input("Enter your query (or 'exit' to quit): ")
        if query.lower() == 'exit':
            break
        results = search(query, index)
        if results:
            print("\n".join(results))
        else:
            print("No results found!")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

这个mini_search_engine函数首先爬取指定数量的URL,然后构建反向索引,并提供一个简单的命令行界面来查询结果。


在这一部分,我们已经了解了如何处理网页内容、构建反向索引以及如何使用这个索引来搜索查询。在下一部分,我们将优化我们的搜索引擎,并提供更高级的功能。

第三部分:优化与高级特性

在前面的部分,我们已经构建了一个基本的搜索引擎,但为了使其更为高效和用户友好,我们需要进行一些优化和增加一些高级特性。

6. 优化爬虫

首先,我们需要确保爬虫不重复爬取同一个网页。为此,我们可以使用哈希函数来检测网页内容的变化。

import hashlib

def get_content_hash(content):
    return hashlib.md5(content.encode()).hexdigest()
  • 1
  • 2
  • 3
  • 4

这个函数会为给定的内容返回一个MD5哈希值。然后,我们可以在simple_crawler函数中使用这个哈希值来检查是否已经爬取过相同内容的网页。

7. 排序搜索结果

当用户进行搜索时,他们通常希望看到最相关的结果。为了实现这一点,我们需要为搜索结果排序。

def score_results(query, results, crawled_data):
    scores = {}
    for url in results:
        content = crawled_data[url]
        scores[url] = content.count(query)
    return sorted(scores, key=scores.get, reverse=True)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

这个简单的打分方法仅仅是基于查询在文档中出现的次数。当然,真实的搜索引擎使用更复杂的打分方法。

8. 实现短语搜索

用户可能想要搜索一个确切的短语,而不是单独的词。为此,我们需要修改我们的search函数。

def phrase_search(query, index, crawled_data):
    words = tokenize(query)
    candidate_urls = set()

    for word in words:
        if word in index:
            if not candidate_urls:
                candidate_urls = index[word]
            else:
                candidate_urls.intersection_update(index[word])

    results = []
    for url in candidate_urls:
        content = crawled_data[url]
        if query in content:
            results.append(url)

    return results
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

9. 整合高级特性

为了集成所有这些高级特性,我们需要修改mini_search_engine函数。

def advanced_mini_search_engine(start_url, limit=50):
    crawled_data = {}
    content_hashes = set()
    urls = simple_crawler(start_url, limit)
    
    for url in urls:
        content = get_webpage(url)
        if content:
            content_hash = get_content_hash(content)
            if content_hash not in content_hashes:
                crawled_data[url] = content
                content_hashes.add(content_hash)

    index = build_reverse_index(crawled_data)

    while True:
        query = input("Enter your query (or 'exit' to quit): ")
        if query.lower() == 'exit':
            break
        results = phrase_search(query, index, crawled_data)
        if results:
            sorted_results = score_results(query, results, crawled_data)
            print("\n".join(sorted_results))
        else:
            print("No results found!")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

总结

在本文中,我们介绍了如何使用Python从零开始构建一个微型搜索引擎。虽然我们的搜索引擎相对简单,但它涵盖了搜索引擎的基本组件,如网络爬虫、文本处理、反向索引和查询处理。

如果您对此感兴趣,并希望进一步扩展功能,可以考虑以下方向:

  • 使用更复杂的文本处理方法,如词干提取和停用词过滤。
  • 实现更高级的打分和排名方法。
  • 优化爬虫,使其更快且更加稳定。
  • 添加用户界面,使其更加用户友好。

希望你喜欢这个指南,并从中学到一些有趣的知识!


这篇文章介绍了如何使用Python构建一个微型搜索引擎。如果你对搜索技术感兴趣,或者想进一步学习Python编程,这是一个很好的起点!

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小蓝xlanll/article/detail/608074
推荐阅读
相关标签
  

闽ICP备14008679号