目录

基于Python的新闻搜索引擎设计与实现的详细项目实例... 2

项目背景介绍... 2

项目目标与意义... 3

提升新闻获取效率与准确性... 3

构建可控可解释的垂直搜索平台... 4

促进自然语言处理与信息检索技术的综合实践... 4

服务多样化应用场景与行业需求... 4

项目挑战及解决方案... 5

新闻数据爬取与反爬机制应对... 5

中文文本处理与索引结构设计... 5

相关性排序与结果质量优化... 5

项目模型架构... 6

数据采集层：新闻抓取与初步清洗... 6

文本预处理层：分词、清洗与特征表示... 6

索引层：倒排索引与文档存储结构... 7

检索与排序层：查询解析、匹配与评分模型... 7

展示与交互层：搜索接口与结果呈现... 7

项目模型描述及代码示例... 8

新闻抓取与页面解析模块示例... 8

基于TF-IDF的基础检索模块示例... 12

BM25评分模型与检索模块示例... 13

简单查询接口与结果摘要生成模块示例... 14

基于Python的新闻搜索引擎设计与实现的详细项目实例

请注意此篇内容只是一个项目介绍 更多详细内容可直接联系博主本人 

 或者访问对应标题的完整博客或者文档下载页面（含完整的程序，GUI设计和代码详解）

基于Python的新闻搜索引擎项目，源于当前信息爆炸时代中“信息过载”和“有效筛选”的矛盾。网络新闻源数量持续增长，门户网站、自媒体平台、权威机构网站不断产出大量实时资讯，但读者获取信息的时间和注意力却非常有限。如果只能依靠传统门户网站的栏目浏览方式，就很难在海量新闻中快速定位到想要的内容。尤其在重大公共事件、行业变革、政策发布、金融市场波动等场景里，信息的“及时、准确、可检索、可追溯”变得尤为关键，因此构建一个可定制、可扩展、可解释的新闻搜索引擎有了非常现实的意义。

传统的通用搜索引擎固然功能强大，但通常作为一个黑盒系统存在：排序标准不透明，很难针对某一个垂直领域（例如财经、医疗、教育、科技）进行细粒度优化；同时，在企业内部或特定业务场景中，出于隐私、保密或合规要求，需要在内网或本地环境中运行一个定制化搜索系统，从而对新闻内容进行统一采集、索引和检索管理。因此，利用Python这一生态成熟、库资源丰富、适合快速开发的语言，从头到尾搭建一个新闻搜索引擎，不仅有助于掌握搜索相关的核心技术要点，也能形成一套可落地的工程化解决方案。

在技术层面，新闻搜索工程涵盖了多个关键环节：新闻源抓取、网页内容解析、文本预处理、倒排索引构建、相关性计算、排名策略、查询解析、界面交互以及日志监控等。每个环节都存在大量细节与权衡，例如抓取频率和反爬策略之间的平衡、中文分词工具的选择与适配、索引结构的设计与更新策略、TF-IDF和BM25等文本匹配算法的选型与组合、用户查询意图理解的深度等等。借助Python生态中的requests、BeautifulSoup、lxml、jieba、scikit-learn等工具，可以相对平滑地把这些环节串联起来，实现一个完整可运行的系统。

这类项目的价值不仅体现在功能层面，更体现在方法论层面。通过构建一个实际运行的新闻搜索引擎，可以直观理解搜索系统为什么需要倒排索引而不是简单全文扫描，为什么需要停止词过滤与分词归一化，为什么需要对新闻标题与正文设置不同的权重，为什么需要考虑时间因素对新闻排序的影响。理论概念通过工程实践被具体化，变成看得见、调得动、可对比的系统行为，这对于掌握信息检索与文本挖掘的核心思想具有非常高的训练价值。

基于Python的新闻搜索引擎，还具备天然的扩展空间和二次开发潜力。一方面，可以从最基础的关键词匹配和TF-IDF排序入手，逐步引入BM25、词向量、句向量、语义检索、个性化推荐等更先进的技术；另一方面，可以很方便地增加新闻情感分析、主题聚类、事件抽取、热点趋势分析等功能，逐渐从“检索工具”演变为“智能信息分析平台”。这类渐进式增强路径，适合在学习过程中不断迭代完善，使项目具有持续演化的生命力。

在应用场景上，这样一个系统既可以服务于个人学习与研究，也可以迁移到企业内部，构建各类行业信息监控平台。例如，为证券公司构建舆情与新闻监控系统，为媒体机构构建稿源搜索平台，为政府部门搭建政策与法规信息库等。通过可控的Python项目结构，可以随时调整抓取源、索引策略和排序规则，从而适配不同业务需求。新闻搜索不再只是一个在浏览器地址栏中输入关键词的抽象动作，而是成为一个可定制、可理解、可扩展的技术体系。

综合来看，基于Python的新闻搜索引擎设计与实现项目，是一个高度贴近实际场景的综合性工程实践。它把网络数据采集、自然语言处理、信息检索、系统架构设计、性能优化和可视化展示等多个技术方向有机结合在一起，既能检验基础编程能力，又能引导掌握更高层次的系统设计思维。通过从零开始构建该系统，可以全面体验一个完整工程项目的规划、实施、调优与维护过程，这种经验对于后续进入更复杂的搜索、推荐或智能问答系统开发领域，有着非常重要的铺垫作用。

项目目标与意义

提升新闻获取效率与准确性

第一项目目标是围绕“更快、更准地找到目标新闻”展开。现实中，面对一个主题，比如“人工智能监管政策”或者“某企业财报解读”，常常需要在搜索引擎中多次输入不同关键词，打开众多页面，然后逐条筛选内容是否相关，过程耗时耗力。通过构建新闻搜索引擎，可以针对新闻文本的结构特点，结合标题、摘要、正文、发布时间等信息进行加权处理，使得排序结果更符合新闻阅读场景。标题中出现的关键词、导语中的重要句子、近期发布的相关文章，都可以在排序中获得更高权重，从而显著提升第一次搜索结果的质量，减少无效点击。通过索引结构的合理设计，在几十万甚至上百万条新闻数据量级上仍然能够保持较快的响应时间，实现近实时搜索体验。系统还可以支持布尔查询、短语搜索、时间范围过滤等高级查询方式，帮助使用者在短时间内锁定高相关度的新闻集合，尤其适用于研究型阅读或工作场景下的资料查找需求。

构建可控可解释的垂直搜索平台

市面上通用搜索引擎的排序和推荐机制通常高度复杂，且属于平台的核心商业机密，对于普通开发者或机构来说难以理解和定制。通过基于Python自行搭建新闻搜索引擎，可以完全掌控爬取源、索引机制、排序策略以及数据更新节奏。系统可以根据业务需求定义哪些媒体为核心权威源，哪些网站为补充源，如何过滤重复稿件，如何处理相同新闻在不同平台的转发版本。排序算法可以公开透明，例如TF-IDF、BM25的计算公式、字段权重、时间衰减函数等都可以在配置中明确呈现，方便调试与审计。对于某些对信息来源和排序逻辑高度敏感的场景（如司法、行政、金融决策），这种可解释性尤为重要。同时，该平台通过开放的数据结构设计和清晰的接口层，可以适配不同前端展示形式，包括Web网页、移动应用、内部管理系统嵌入的搜索组件等，实现灵活的垂直搜索能力，提升组织内部的信息化水平和自主可控能力。

促进自然语言处理与信息检索技术的综合实践

该项目的另一个重要意义是作为自然语言处理和信息检索技术的综合实践平台。基于Python实现新闻搜索，能够把分词、停用词过滤、词频统计、文本向量化、相关性计算、排序策略、查询扩展等理论知识以工程形式串联起来。通过实际编码，可以清晰体会TF-IDF为什么可以表示关键词的重要程度，BM25为什么较传统TF-IDF有更好的长度归一化效果，倒排索引为何比顺序扫描快几个数量级。还可以逐步引入更高级技术，例如利用词向量或句向量进行语义相似度计算，用深度学习模型进行新闻分类，用主题模型识别新闻聚类结构，将语义检索与关键词检索相结合。项目过程可以变成一个持续的实验和迭代平台，通过在真实的新闻语料上不断测试不同算法和参数组合，观察检索效果和排序结果变化，从而深化对自然语言处理与信息检索核心思想的理解。

服务多样化应用场景与行业需求

新闻搜索引擎不仅仅是一种工具，更是一种基础设施，可以支撑多个行业级应用场景。在舆情监控方面，可以把新闻搜索引擎作为核心模块，实时抓取并索引与某个企业、品牌、人物或事件有关的新闻，结合关键词监控规则，对负面新闻或敏感话题进行自动预警。在金融投资领域，可以围绕行业、公司、政策等维度构建专用新闻搜索系统，帮助分析师快速检索特定公司过往的重大新闻、公告解读和分析文章，为投资决策提供更全面的舆论背景支持。在企业内部知识管理场景中，可以扩展抓取源到企业的公告、对外发布稿件和媒体报道，从而形成统一的新闻与外部信息门户，支持员工根据项目、客户、产品等维度快速检索。通过这一项目，可以验证并展示搜索技术在多个垂直领域的适配能力，从而为后续的商业化或产品化打下基础，也为个体开发者或团队积累在垂直搜索领域的经验和技术资产。

项目挑战及解决方案

新闻数据爬取与反爬机制应对

新闻搜索系统的生命线在于高质量、持续更新的数据来源。实际构建过程中，新闻数据爬取往往面临多重挑战：网站结构多样且频繁调整，部分媒体采用动态加载或异步接口，很多站点部署了人机识别、访问频率限制、User-Agent检测、IP封锁等反爬机制。内容抽取层面，不同网站的HTML结构差异很大，新闻标题、发布时间、正文、作者、来源信息的位置和标记不统一，简单基于标签名称的解析方式常常失效。为解决这些问题，爬取模块需要采用模块化、配置驱动的设计思路，对每个新闻源单独定义解析规则，并尽可能使用稳健的选择策略，如结合DOM层级结构、属性特征、正则表达式等方法定位正文区域。同时，在访问层要严格控制请求频率，合理设置延迟和并发数量，使用随机的User-Agent池，必要时结合代理池策略，既保护目标网站压力，又降低被封禁风险。对于动态加载内容，可以通过分析网络请求抓取实际JSON数据接口，或利用轻量级无头浏览器方案获取渲染后的HTML。通过日志系统监控抓取状态，一旦某个源结构变动导致失败，可以快速定位并更新解析配置，保持系统稳定运行。

中文文本处理与索引结构设计

中文新闻的文本处理存在与英文不同的特点，最大难点在于分词和词形归一。中文没有空格作为天然分隔符，切分单词需要依靠词典和统计模型，而新闻文本中既包含通用词汇，又包含大量人名、地名、机构名、专业术语和新词，通用分词工具往往会出现切分不准确的问题。为提高分词质量，需要结合领域词典和停用词表，对新闻领域常见的实体词进行自定义词典扩展，并对虚词、标点、无意义高频词进行过滤，以提升索引的有效性。此外，中文在标点、全半角、繁简体等方面也需要统一规范处理，避免同一概念在索引中被分裂为多个形式。倒排索引结构的设计同样重要，需要在内存占用、查询速度和更新效率之间做平衡：索引中不仅要记录每个词出现在哪些文档（新闻），还需要存储词频、位置、字段信息（标题或正文）等，以支持短语查询、字段加权等高级功能。通过合适的数据结构（如字典嵌套、压缩存储、分块索引等）以及持久化策略（如将索引定期保存为二进制文件或使用轻量数据库），可以在保证搜索性能的同时，控制资源占用，并支持未来的增量更新和扩展。

相关性排序与结果质量优化

从用户视角来看，搜索体验好坏很大程度取决于结果排序是否符合直觉，是否能在前几条结果里找到需要的内容。对于新闻搜索而言，相关性排序不仅受关键词匹配程度影响，还受到时间因素、新闻来源权威性、标题匹配情况、内容丰富程度等多个维度的综合影响。单纯依赖关键词匹配容易出现“关键词在很长正文中出现几次但与核心主题关系不大”的情况，也可能忽略标题或导语中高度浓缩的信息。解决这一挑战需要合理设计相关性评分模型，常见做法是结合TF-IDF或BM25作为基础文本匹配分数，同时引入字段权重（标题命中得分更高）、时间衰减函数（近期新闻得分略高）、来源权威度（可信媒体适当加权）等因素，构成一个可配置的综合评分公式。通过在真实数据上进行对比实验，例如选取几个典型查询词，对比不同评分参数组合下前若干条结果的质量，可以逐步调优排序策略。此外，还可以在后期引入轻量级学习排序思想，通过人工标注部分查询-结果排序样本，训练一个简单模型（如线性模型或基于树的模型）对不同特征进行加权，从而在不引入过高复杂度的前提下，提升结果质量。持续采集查询日志和点击行为数据，也有助于后续对排序算法进行更加精细的优化和个性化调整。

项目模型架构

数据采集层：新闻抓取与初步清洗

数据采集层负责从不同新闻源持续获取新内容，构成整个系统的“数据入口”。这一层通常由若干抓取任务组成，每个任务对应一个或一组新闻网站，使用统一的抓取框架和调度机制。通过requests库发起HTTP请求，从新闻列表页逐条获取新闻详情页链接，再请求详情页获取完整HTML内容。针对动态加载的新闻源，通过分析浏览器开发者工具中的网络请求，找到底层JSON接口或API，从而直接获取结构化数据，避免复杂的HTML解析。初步清洗环节包括去除广告脚本、无关导航文本、评论区信息等，保留标题、发布时间、正文、作者、来源等关键字段。为适应网站结构的多样性，在架构上通常采用策略模式或配置驱动方式，为每个新闻源定义解析规则，如使用CSS选择器、XPath表达式或特征关键词定位正文区域，并在代码中统一管理。采集层还需要集成错误重试、异常记录、抓取状态统计等功能，防止单个源错误影响整体抓取流程。通过定时调度（例如使用定时任务组件），周期性触发抓取任务，使索引数据始终保持相对新鲜，满足新闻场景对时效性的要求。

文本预处理层：分词、清洗与特征表示

文本预处理层是连接原始新闻内容与检索模型的关键桥梁。在这一层，会对每条新闻的标题和正文进行统一的规范化处理。首先进行字符级清洗，包括去除HTML标签残留、转义字符、冗余空白符等，将内容转换为统一编码格式，统一全角半角符号，并可选进行繁简体转换。随后是中文分词与停用词过滤，利用jieba等分词工具对文本进行切分，将连续的字符序列划分为有意义的词语；同时加载自定义词典，将常见的人名、地名、机构名和专业术语纳入词表，提高切分准确度。对分词结果，过滤掉停用词，如“的”“了”“在”等不承载关键信息的功能词，以突出文档中的核心语义。在特征表示方面，为后续索引与检索服务，一般需要记录每个词在文档中的出现次数、位置（词在文档中的下标）、所在字段（标题或正文），并统计整篇文档的长度（词数），这些信息将作为TF-IDF或BM25等算法的输入特征。对于进一步的扩展，还可以在这一层构建新闻的向量化表示，例如使用TF-IDF向量、词袋模型、甚至句向量模型，将文本转换为可用于相似度计算的数值向量，为后续语义检索和聚类分析打基础。

索引层：倒排索引与文档存储结构

索引层是新闻搜索引擎的核心基础设施，负责将预处理后的文本信息组织成可快速查询的结构。倒排索引是这一层的主角，其基本思想是从“文档-词列表”的正向关系反转为“词-文档列表”的映射。具体而言，对于每个分词后的词项，记录它出现在哪些文档中，并为每个文档记录该词的词频、出现位置等信息，形成一个类似于“词典”的结构。查询时只需根据用户输入的词项快速定位对应的文档集合，再通过计算相关性分数进行排序即可，避免对所有文档逐个扫描，从而大幅提升检索效率。在实现上，索引层通常使用嵌套字典或映射结构，将词项映射到文档ID和词频记录，同时维护文档ID到文档元数据（标题、URL、发布时间、长度等）的映射表。为提高查询性能，可以对高频词项进行压缩存储或分片处理，并对索引数据进行持久化，使系统重启后无需重新构建索引。索引层设计时还需要考虑更新策略：新闻具有时间流入特性，新的文档不断加入，因此需要支持增量索引更新，避免每次从零重建索引。同时可以通过拆分主索引和增量索引的方式，定期合并以保持结构紧凑和查询高效。

检索与排序层：查询解析、匹配与评分模型

检索与排序层负责处理输入查询，将其转换为可用于搜索的内部表示，并对候选文档进行相关性评分与排序。查询解析阶段，将用户输入进行基础预处理和分词，同样使用与索引阶段一致的分词工具和停用词规则，以确保词项空间统一。对于包含多个词项的查询，可以支持布尔运算（如AND、OR逻辑）和短语匹配，通过对倒排索引中多个词项的文档列表进行交集、并集或邻接位置判断，筛选出候选文档集合。相关性评分模型则是这一层的技术核心，常见做法是基于TF-IDF或BM25算法：TF反映词在文档中的出现频率，IDF反映词在整个语料中出现的稀有程度，二者结合可以衡量词对文档的重要性；BM25进一步引入文档长度归一化和参数调节，使模型在长文档与短文本场景下表现更加稳定。实际排序时，通常会对标题、正文设置不同权重，例如标题中命中的词对评分贡献更大，同时引入发布时间的衰减函数，使近期新闻在同等相关性下获得更高排名。此外，如果已经为文档构建了向量化表示，还可以在关键词匹配基础上加入向量相似度评分，形成混合排序机制。检索与排序层需要在效率与准确性之间取得平衡，既要保证搜索响应时间足够快，又要通过合理的评分策略提升结果质量。

展示与交互层：搜索接口与结果呈现

展示与交互层面向最终使用者，负责提供友好的搜索入口和清晰的结果展示形式。在Web应用中，通常通过一个简单的搜索框接收用户输入的查询，然后通过HTTP接口调用后端检索服务，获取排序后的结果列表。结果展示页面会为每条新闻显示标题、摘要（从正文中抽取包含关键词的片段）、来源网站、发布时间和链接地址等信息，并用高亮颜色标注匹配的关键词，方便快速浏览相关性。为提升交互体验，可以提供分页、每页数量选择、按时间排序、按来源过滤等功能，还可以增加“只看标题匹配”或“限定时间范围”的高级搜索选项，满足更精细的检索需求。在架构上，展示层与检索层通过明确定义的API接口解耦，前端只需要提交查询参数并渲染返回的JSON结果，不需要关心内核的索引与排序实现。这样不仅便于前后端协同开发，也为未来扩展到移动端、桌面端或其他系统嵌入式组件提供了灵活性。展示与交互层还可以集成日志记录，对查询词、点击行为等进行统计和可视化，为后续分析用户需求、优化排序策略提供数据基础。通过合理的界面设计与交互细节打磨，使整个搜索体验自然顺畅，降低使用门槛，提升系统的实用性和可接受度。

项目模型描述及代码示例

新闻抓取与页面解析模块示例
import requests # 导入requests库，用于发送HTTP请求获取网页内容
from bs4 import BeautifulSoup # 导入BeautifulSoup，用于解析HTML结构并提取需要的元素
from datetime import datetime # 导入datetime，用于解析和标准化新闻发布时间
    response = requests.get(url, headers=self.headers, timeout=10)  # 使用GET请求抓取网页内容并设置超时时间避免长时间阻塞  
    response.raise_for_status()  # 若状态码异常则抛出错误，方便外层捕获与日志记录  
    response.encoding = response.apparent_encoding  # 自动根据响应内容推断编码，避免乱码问题  
    return response.text  # 返回解码后的HTML文本供后续解析处理  
def parse_list_page(self, html):  # 定义解析新闻列表页的方法，输入HTML文本  
    soup = BeautifulSoup(html, "html.parser")  # 使用HTML解析器构造BeautifulSoup对象，对DOM结构进行分析  
        href = a.get("href", "")  # 安全地获取href属性，若不存在则返回空字符串  
        title = (a.get_text() or "").strip()  # 获取链接文字内容，去除多余空白符，以提取可能的标题文本  
        if not href or not title:  # 若链接或文字为空，则跳过，无意义的数据不参与后续处理  
            continue  # 直接进入下一轮循环  
        if "news" in href or "article" in href:  # 简单通过URL模式判断该链接是否可能指向新闻详情页  
            full_url = href if href.startswith("http") else self.base_url + href  # 若为相对路径则拼接成完整URL  
            links.append({"url": full_url, "title": title})  # 将URL和标题组成字典加入列表，供后续抓取详情使用  
    return links  # 返回收集到的列表页新闻链接集合  
def parse_detail_page(self, html):  # 定义解析新闻详情页的方法，输入新闻页面HTML文本  
    soup = BeautifulSoup(html, "html.parser")  # 使用BeautifulSoup解析HTML，便于定位标题和正文等元素  
    title_tag = soup.find("h1")  # 尝试找到一级标题标签，很多新闻页面将主标题放在h1标签  
    title = title_tag.get_text().strip() if title_tag else ""  # 若找到标题标签则提取其文本内容并去除空白，否则为空字符串  
    time_tag = soup.find("span", class_="time")  # 尝试根据类名找到发布时间标签，这是常见的标记方式之一  
    pub_time_raw = time_tag.get_text().strip() if time_tag else ""  # 若存在时间标签则提取文本进行清洗  
    try:  # 使用try块容错时间解析过程中的格式差异  
        pub_time = datetime.strptime(pub_time_raw, "%Y-%m-%d %H:%M")  # 按指定格式解析时间字符串为datetime对象  
        pub_time = None  # 将发布时间设置为None，后续系统可根据需要进行替代处理或忽略  
    content_div = soup.find("div", class_="content")  # 尝试定位正文所在的div标签，许多站点使用content类名  
    if content_div:  # 若成功找到正文容器，则进行文本提取  
        for p in content_div.find_all("p"):  # 遍历正文容器下的所有段落p标签  
            txt = (p.get_text() or "").strip()  # 获取段落文本并去除首尾空白  
            if txt:  # 如果文本非空，则认为是有效内容  
    return {  # 返回一个包含新闻关键信息的字典  
        "title": title,  # 标题字段存放解析出的新闻标题文本  
        "pub_time": pub_time,  # 发布时间字段存放解析出的时间对象或None  
    }  # 完成详情页解析方法返回  

def crawl_list_page(self, page_index=1):  # 定义爬取列表页并解析链接的方法，page_index用于支持分页  
    if not url.startswith("http"):  # 若路径为相对路径，需要与基础URL进行拼接  
        url = self.base_url + url  # 拼接成完整的HTTP地址  
    links = self.parse_list_page(html)  # 调用parse_list_page从列表页中解析出新闻链接  
    return links  # 返回当前列表页抽取出的新闻链接集合  

    html = self.fetch_html(url)  # 使用fetch_html获取该详情页HTML内容  
    data = self.parse_detail_page(html)  # 调用parse_detail_page解析HTML为结构化新闻数据  
    data["url"] = url  # 在解析结果中补充原始新闻URL，方便后续展示与索引  
import re # 导入正则表达式库，用于进行文本的规则化清洗操作
import jieba # 导入jieba中文分词库，用于将连续中文文本切分成词语序列
class TextPreprocessor: # 定义文本预处理类，用于封装清洗与分词等逻辑
def init(self, stopwords_path=None, user_dict_path=None): # 初始化方法，允许指定停用词表和用户词典路径
self.stopwords = set() # 初始化一个空集合，用于存储停用词，集合结构便于高效查询
if stopwords_path: # 若提供了停用词文件路径，则加载停用词
with open(stopwords_path, "r", encoding="utf-8") as f: # 打开停用词文件，并使用utf-8编码读取
for line in f: # 遍历文件中的每一行，逐条处理停用词
word = line.strip() # 去除每行首尾空白符获取实际的停用词文本
if word: # 若该行不为空，则认为是有效停用词
self.stopwords.add(word) # 将该停用词添加到集合中，供后续过滤使用
if user_dict_path: # 若提供了用户词典路径，则加载自定义词典
jieba.load_userdict(user_dict_path) # 调用jieba的接口加载用户词典，提高新闻领域分词准确度
        return ""  # 返回空字符串作为清洗结果  
    text = re.sub(r"<[^>]+>", " ", text)  # 移除潜在的HTML标签，将其替换为空格避免内容黏连  
    text = re.sub(r"\s+", " ", text)  # 将连续空白字符压缩为单个空格，使文本更加规整  
    return text.strip()  # 去除首尾空白并返回清洗后的文本  

    clean = self.clean_text(text)  # 首先对原始文本进行清洗，去除标签与冗余空白  
    words = jieba.lcut(clean)  # 使用jieba精确模式直接将整段文本切分成词语列表  
    tokens = []  # 初始化列表，用于存放经过过滤处理的有效词语  
    for w in words:  # 遍历分词结果中的每个词  
        w = w.strip()  # 去除词语首尾可能的空白符  
            continue  # 进入下一轮循环  
        if w in self.stopwords:  # 若该词为停用词，则不保留在结果中  
            continue  # 跳过当前词  
        tokens.append(w)  # 将保留的词语加入tokens列表  

def tokenize_with_positions(self, text):  # 定义带位置记录的分词方法，便于后续构建倒排索引  
    clean = self.clean_text(text)  # 清洗文本去除噪声字符  
    words = jieba.lcut(clean)  # 使用jieba进行分词得到顺序词列表  
    result = []  # 初始化结果列表，其中每个元素包含词语及其在文中的位置索引  
    position = 0  # 初始化位置计数器，从0开始递增记录词在文本中的顺序  
    for w in words:  # 遍历分词结果中的每个词  
        w = w.strip()  # 去除首尾空白以防止空词产生  
        if not w:  # 若为空则跳过  
            continue  # 直接进行下一词处理  
        if w in self.stopwords:  # 若该词在停用词表中则跳过  
        result.append((w, position))  # 将词语与当前位置信息组成元组加入结果列表  
        position += 1  # 位置计数器加一，为下一个词记录提供更新位置  
    return result  # 返回包含词语和位置的列表，为构建倒排索引提供基础  
from collections import defaultdict # 导入defaultdict，便于为不存在的键提供默认值并简化代码结构
import math # 导入math库，用于后续计算IDF等需要对数函数的部分
def add_document(self, doc_id, title, content, url=None, pub_time=None, preprocessor=None):  # 定义添加文档到索引的方法  
    if preprocessor is None:  # 若未提供预处理器，则无法继续构建索引  
        raise ValueError("TextPreprocessor instance required")  # 抛出异常提示调用者必须提供预处理器对象  
    title_tokens = preprocessor.tokenize_with_positions(title)  # 使用预处理器对标题进行分词并记录位置  
    content_tokens = preprocessor.tokenize_with_positions(content)  # 使用预处理器对正文进行分词并记录位置  
    all_tokens = []  # 初始化列表，用于统一存放标题和正文中的词与位置  
    for w, pos in title_tokens:  # 遍历标题分词结果  
        all_tokens.append((w, pos, "title"))  # 将词语、原始位置和字段类型标记为title加入列表  
    offset = len(title_tokens)  # 使用标题长度作为正文起始位置的偏移量，防止位置索引冲突  
    for w, pos in content_tokens:  # 遍历正文分词结果  
    self.doc_meta[doc_id] = {  # 在文档元数据表中保存当前文档的基本信息  
        "url": url,  # 保存新闻来源URL，供前端点击访问  
        "pub_time": pub_time  # 保存发布时间，以支持时间排序和过滤  
    }  # 完成文档元数据字典赋值  
    for w, pos, field in all_tokens:  # 遍历组合后的所有词项及其位置和字段信息  
        if doc_id not in self.index[w]:  # 若倒排索引中尚无该词在此文档的记录  
                "tf": 0,  # 初始化词频计数为0  
                "positions": [],  # 初始化位置列表，用于存储词在文中的所有出现位置  
            }  # 完成该词在该文档的记录初始化  
        self.index[w][doc_id]["positions"].append(pos)  # 记录该词在文中的位置索引，便于短语匹配等高级功能  

def idf(self, term):  # 定义计算某个词的IDF值的方法  
    df = len(self.index.get(term, {}))  # 通过倒排索引获取该词的文档频次，即出现在多少文档中  
        return 0.0  # 对于未见词，IDF设为0表示其无贡献  
    return math.log((self.doc_count + 1) / (df + 1)) + 1.0  # 使用平滑后的IDF公式，避免除零并略微提升稀有词权重  
基于TF-IDF的基础检索模块示例
class TfidfSearcher: # 定义基于TF-IDF进行检索的搜索类
def init(self, index, preprocessor): # 初始化方法，接收倒排索引实例和文本预处理器
self.index = index # 保存倒排索引引用，以便在搜索时访问词项与文档关系
self.preprocessor = preprocessor # 保存预处理器引用，用作对查询字符串进行分词与清洗
self.avg_doc_len = self._compute_avg_doc_length() # 预计算文档平均长度，虽在TF-IDF中可选但为后续扩展提供便利
    if not self.index.doc_lengths:  # 若尚未有任何文档长度记录，则返回0避免除零  
    return total_len / len(self.index.doc_lengths)  # 用总长度除以文档数得到平均长度  

def search(self, query, top_k=10):  # 定义搜索方法，输入查询字符串与返回结果的数量上限  
    tokens = self.preprocessor.tokenize(query)  # 对查询语句进行分词和停用词过滤，得到有效词列表  
    scores = defaultdict(float)  # 使用defaultdict存储文档得分，默认初始值为0.0便于累加  
    for term in tokens:  # 遍历查询中的每个词项  
        postings = self.index.index.get(term)  # 从倒排索引中获取该词对应的文档记录集合  
        if not postings:  # 若该词不在任何文档中出现，则跳过  
            continue  # 进行下一词项处理  
        for doc_id, info in postings.items():  # 遍历该词在不同文档中的记录  
            tf = info["tf"]  # 获取该词在当前文档中的出现次数  
            scores[doc_id] += tf_weight * idf_value  # 将该词对该文档的贡献加到文档总得分上  

    ranked = sorted(scores.items(), key=lambda x: x[1], reverse=True)  # 将文档按得分从高到低排序得到排名列表  
    results = []  # 初始化结果列表，用于存放结构化的搜索结果条目  
    for doc_id, score in ranked[:top_k]:  # 遍历前top_k条文档得分记录  
        meta = self.index.doc_meta.get(doc_id, {})  # 获取该文档的元数据，如标题和URL等  
            "title": meta.get("title", ""),  # 从元数据中获取标题，若不存在则为空字符串  
            "url": meta.get("url"),  # 从元数据中获取原始新闻链接地址  
            "score": score  # 保存该文档的相关性得分，便于客户端展示或分析  
    return results  # 返回完整的搜索结果列表  
BM25评分模型与检索模块示例
def _compute_avg_doc_length(self):  # 内部方法，用于计算平均文档长度  
    if not self.index.doc_lengths:  # 若当前没有任何文档长度记录  
        return 0.0  # 返回0表示平均长度不可用  
    total_len = sum(self.index.doc_lengths.values())  # 累加所有文档长度得到总长度  

def bm25_score(self, tf, doc_len, idf_value):  # 定义BM25单词项得分计算函数  
    numerator = tf * (self.k1 + 1)  # 计算分子部分，将词频乘以k1+1增强作用  
    denominator = tf + self.k1 * (1 - self.b + self.b * (doc_len / self.avg_doc_len + 1e-9))  # 计算分母，综合词频和长度归一项并添加微小常数防止除零  
    return idf_value * (numerator / denominator)  # 返回BM25得分，IDF与TF加权比值的乘积  

    tokens = self.preprocessor.tokenize(query)  # 对查询文本进行分词，得到关键词列表  
    for term in tokens:  # 遍历每个查询词项  
        postings = self.index.index.get(term)  # 从倒排索引中取出该词的文档记录  
        if not postings:  # 若该词在索引中不存在  
            continue  # 跳过当前词  
        for doc_id, info in postings.items():  # 遍历该词对应的各文档信息  
            tf = info["tf"]  # 获取该词在当前文档中的词频  
            doc_len = self.index.doc_lengths.get(doc_id, 0)  # 获取当前文档长度，若不存在则视为0  
            score_increment = self.bm25_score(tf, doc_len, idf_value)  # 调用bm25_score计算这对词与文档的得分贡献  
            if "title" in info["fields"]:  # 若该词出现在标题字段中  
                score_increment *= 1.2  # 适当放大该词对总分的贡献，体现标题的更高权重  
            scores[doc_id] += score_increment  # 将当前词对该文档的贡献累加到总得分中  

    ranked = sorted(scores.items(), key=lambda x: x[1], reverse=True)  # 按得分从高到低排序得到文档排名  
    results = []  # 初始化搜索结果列表  
    for doc_id, score in ranked[:top_k]:  # 取前top_k个高分文档进行封装  
        meta = self.index.doc_meta.get(doc_id, {})  # 从文档元数据表中获取当前文档的基本信息  
        results.append({  # 构造单条搜索结果记录  
            "doc_id": doc_id,  # 保存文档ID  
            "title": meta.get("title", ""),  # 保存文档标题文本  
        })  # 完成单条结果结构化  
    return results  # 返回完整的BM25搜索结果列表  
简单查询接口与结果摘要生成模块示例
class SimpleSearchService: # 定义简易搜索服务类，用于整合搜索器与结果加工逻辑
def init(self, searcher, preprocessor, index): # 初始化方法，接收搜索器、预处理器与倒排索引
self.searcher = searcher # 保存具体搜索器实例，可以是TF-IDF或BM25搜索器
self.preprocessor = preprocessor # 保存文本预处理器实例，用于查询和摘要相关处理
self.index = index # 保存倒排索引实例，用于根据文档ID取回原始内容
    title = meta.get("title", "")  # 从元数据中读取标题文本，若无则为空字符串  
    clean_title = self.preprocessor.clean_text(title)  # 对标题进行清洗，移除潜在标签与冗余空白  
    if len(clean_title) <= snippet_length:  # 若标题长度不超过预期摘要长度  
        return clean_title  # 直接返回整段标题作为摘要  
    return clean_title[:snippet_length] + "..."  # 若标题较长则截取指定长度并添加省略号  
def search_with_snippets(self, query, top_k=10):  # 定义带摘要生成的搜索方法  
    raw_results = self.searcher.search(query, top_k=top_k)  # 调用底层搜索器执行查询获取原始结果列表  
    enhanced_results = []  # 初始化增强结果列表，将在原始结果基础上附加摘要信息  
    for item in raw_results:  # 遍历每条原始结果记录  
        doc_id = item["doc_id"]  # 取出当前记录的文档ID  
        snippet = self.make_snippet(doc_id, query)  # 调用make_snippet生成该文档的摘要文本  
        new_item = dict(item)  # 复制原始结果字典，避免直接修改原对象  
        new_item["snippet"] = snippet  # 在新字典中添加摘要字段  
        enhanced_results.append(new_item)  # 将增强后的结果条目添加到结果列表中  
return enhanced_results  # 返回包含摘要的完整搜索结果集合  

新闻抓取与页面解析模块示例

import requests # 导入requests库，用于发送HTTP请求获取网页内容
from bs4 import BeautifulSoup # 导入BeautifulSoup，用于解析HTML结构并提取需要的元素
from datetime import datetime # 导入datetime，用于解析和标准化新闻发布时间

    response = requests.get(url, headers=self.headers, timeout=10)  # 使用GET请求抓取网页内容并设置超时时间避免长时间阻塞  

    response.raise_for_status()  # 若状态码异常则抛出错误，方便外层捕获与日志记录  

    response.encoding = response.apparent_encoding  # 自动根据响应内容推断编码，避免乱码问题  

    return response.text  # 返回解码后的HTML文本供后续解析处理  

def parse_list_page(self, html):  # 定义解析新闻列表页的方法，输入HTML文本  

    soup = BeautifulSoup(html, "html.parser")  # 使用HTML解析器构造BeautifulSoup对象，对DOM结构进行分析  

        href = a.get("href", "")  # 安全地获取href属性，若不存在则返回空字符串  

        title = (a.get_text() or "").strip()  # 获取链接文字内容，去除多余空白符，以提取可能的标题文本  

        if not href or not title:  # 若链接或文字为空，则跳过，无意义的数据不参与后续处理  

            continue  # 直接进入下一轮循环  

        if "news" in href or "article" in href:  # 简单通过URL模式判断该链接是否可能指向新闻详情页  

            full_url = href if href.startswith("http") else self.base_url + href  # 若为相对路径则拼接成完整URL  

            links.append({"url": full_url, "title": title})  # 将URL和标题组成字典加入列表，供后续抓取详情使用  

    return links  # 返回收集到的列表页新闻链接集合  

def parse_detail_page(self, html):  # 定义解析新闻详情页的方法，输入新闻页面HTML文本  

    soup = BeautifulSoup(html, "html.parser")  # 使用BeautifulSoup解析HTML，便于定位标题和正文等元素  

    title_tag = soup.find("h1")  # 尝试找到一级标题标签，很多新闻页面将主标题放在h1标签  

    title = title_tag.get_text().strip() if title_tag else ""  # 若找到标题标签则提取其文本内容并去除空白，否则为空字符串  

    time_tag = soup.find("span", class_="time")  # 尝试根据类名找到发布时间标签，这是常见的标记方式之一  

    pub_time_raw = time_tag.get_text().strip() if time_tag else ""  # 若存在时间标签则提取文本进行清洗  

    try:  # 使用try块容错时间解析过程中的格式差异  

        pub_time = datetime.strptime(pub_time_raw, "%Y-%m-%d %H:%M")  # 按指定格式解析时间字符串为datetime对象  

        pub_time = None  # 将发布时间设置为None，后续系统可根据需要进行替代处理或忽略  

    content_div = soup.find("div", class_="content")  # 尝试定位正文所在的div标签，许多站点使用content类名  

    if content_div:  # 若成功找到正文容器，则进行文本提取  

        for p in content_div.find_all("p"):  # 遍历正文容器下的所有段落p标签  

            txt = (p.get_text() or "").strip()  # 获取段落文本并去除首尾空白  

            if txt:  # 如果文本非空，则认为是有效内容  

    return {  # 返回一个包含新闻关键信息的字典  

        "title": title,  # 标题字段存放解析出的新闻标题文本  

        "pub_time": pub_time,  # 发布时间字段存放解析出的时间对象或None  

    }  # 完成详情页解析方法返回  

def crawl_list_page(self, page_index=1):  # 定义爬取列表页并解析链接的方法，page_index用于支持分页  

    if not url.startswith("http"):  # 若路径为相对路径，需要与基础URL进行拼接  

        url = self.base_url + url  # 拼接成完整的HTTP地址  

    links = self.parse_list_page(html)  # 调用parse_list_page从列表页中解析出新闻链接  

    return links  # 返回当前列表页抽取出的新闻链接集合  

    html = self.fetch_html(url)  # 使用fetch_html获取该详情页HTML内容  

    data = self.parse_detail_page(html)  # 调用parse_detail_page解析HTML为结构化新闻数据  

    data["url"] = url  # 在解析结果中补充原始新闻URL，方便后续展示与索引  

import re # 导入正则表达式库，用于进行文本的规则化清洗操作
import jieba # 导入jieba中文分词库，用于将连续中文文本切分成词语序列

class TextPreprocessor: # 定义文本预处理类，用于封装清洗与分词等逻辑
def init(self, stopwords_path=None, user_dict_path=None): # 初始化方法，允许指定停用词表和用户词典路径
self.stopwords = set() # 初始化一个空集合，用于存储停用词，集合结构便于高效查询
if stopwords_path: # 若提供了停用词文件路径，则加载停用词
with open(stopwords_path, "r", encoding="utf-8") as f: # 打开停用词文件，并使用utf-8编码读取
for line in f: # 遍历文件中的每一行，逐条处理停用词
word = line.strip() # 去除每行首尾空白符获取实际的停用词文本
if word: # 若该行不为空，则认为是有效停用词
self.stopwords.add(word) # 将该停用词添加到集合中，供后续过滤使用
if user_dict_path: # 若提供了用户词典路径，则加载自定义词典
jieba.load_userdict(user_dict_path) # 调用jieba的接口加载用户词典，提高新闻领域分词准确度

        return ""  # 返回空字符串作为清洗结果  

    text = re.sub(r"<[^>]+>", " ", text)  # 移除潜在的HTML标签，将其替换为空格避免内容黏连  

    text = re.sub(r"\s+", " ", text)  # 将连续空白字符压缩为单个空格，使文本更加规整  

    return text.strip()  # 去除首尾空白并返回清洗后的文本  

    clean = self.clean_text(text)  # 首先对原始文本进行清洗，去除标签与冗余空白  

    words = jieba.lcut(clean)  # 使用jieba精确模式直接将整段文本切分成词语列表  

    tokens = []  # 初始化列表，用于存放经过过滤处理的有效词语  

    for w in words:  # 遍历分词结果中的每个词  

        w = w.strip()  # 去除词语首尾可能的空白符  

            continue  # 进入下一轮循环  

        if w in self.stopwords:  # 若该词为停用词，则不保留在结果中  

            continue  # 跳过当前词  

        tokens.append(w)  # 将保留的词语加入tokens列表  

def tokenize_with_positions(self, text):  # 定义带位置记录的分词方法，便于后续构建倒排索引  

    clean = self.clean_text(text)  # 清洗文本去除噪声字符  

    words = jieba.lcut(clean)  # 使用jieba进行分词得到顺序词列表  

    result = []  # 初始化结果列表，其中每个元素包含词语及其在文中的位置索引  

    position = 0  # 初始化位置计数器，从0开始递增记录词在文本中的顺序  

    for w in words:  # 遍历分词结果中的每个词  

        w = w.strip()  # 去除首尾空白以防止空词产生  

        if not w:  # 若为空则跳过  

            continue  # 直接进行下一词处理  

        if w in self.stopwords:  # 若该词在停用词表中则跳过  

        result.append((w, position))  # 将词语与当前位置信息组成元组加入结果列表  

        position += 1  # 位置计数器加一，为下一个词记录提供更新位置  

    return result  # 返回包含词语和位置的列表，为构建倒排索引提供基础  

from collections import defaultdict # 导入defaultdict，便于为不存在的键提供默认值并简化代码结构
import math # 导入math库，用于后续计算IDF等需要对数函数的部分

def add_document(self, doc_id, title, content, url=None, pub_time=None, preprocessor=None):  # 定义添加文档到索引的方法  

    if preprocessor is None:  # 若未提供预处理器，则无法继续构建索引  

        raise ValueError("TextPreprocessor instance required")  # 抛出异常提示调用者必须提供预处理器对象  

    title_tokens = preprocessor.tokenize_with_positions(title)  # 使用预处理器对标题进行分词并记录位置  

    content_tokens = preprocessor.tokenize_with_positions(content)  # 使用预处理器对正文进行分词并记录位置  

    all_tokens = []  # 初始化列表，用于统一存放标题和正文中的词与位置  

    for w, pos in title_tokens:  # 遍历标题分词结果  

        all_tokens.append((w, pos, "title"))  # 将词语、原始位置和字段类型标记为title加入列表  

    offset = len(title_tokens)  # 使用标题长度作为正文起始位置的偏移量，防止位置索引冲突  

    for w, pos in content_tokens:  # 遍历正文分词结果  

    self.doc_meta[doc_id] = {  # 在文档元数据表中保存当前文档的基本信息  

        "url": url,  # 保存新闻来源URL，供前端点击访问  

        "pub_time": pub_time  # 保存发布时间，以支持时间排序和过滤  

    }  # 完成文档元数据字典赋值  

    for w, pos, field in all_tokens:  # 遍历组合后的所有词项及其位置和字段信息  

        if doc_id not in self.index[w]:  # 若倒排索引中尚无该词在此文档的记录  

                "tf": 0,  # 初始化词频计数为0  

                "positions": [],  # 初始化位置列表，用于存储词在文中的所有出现位置  

            }  # 完成该词在该文档的记录初始化  

        self.index[w][doc_id]["positions"].append(pos)  # 记录该词在文中的位置索引，便于短语匹配等高级功能  

def idf(self, term):  # 定义计算某个词的IDF值的方法  

    df = len(self.index.get(term, {}))  # 通过倒排索引获取该词的文档频次，即出现在多少文档中  

        return 0.0  # 对于未见词，IDF设为0表示其无贡献  

    return math.log((self.doc_count + 1) / (df + 1)) + 1.0  # 使用平滑后的IDF公式，避免除零并略微提升稀有词权重  

基于TF-IDF的基础检索模块示例

class TfidfSearcher: # 定义基于TF-IDF进行检索的搜索类
def init(self, index, preprocessor): # 初始化方法，接收倒排索引实例和文本预处理器
self.index = index # 保存倒排索引引用，以便在搜索时访问词项与文档关系
self.preprocessor = preprocessor # 保存预处理器引用，用作对查询字符串进行分词与清洗
self.avg_doc_len = self._compute_avg_doc_length() # 预计算文档平均长度，虽在TF-IDF中可选但为后续扩展提供便利

    if not self.index.doc_lengths:  # 若尚未有任何文档长度记录，则返回0避免除零  

    return total_len / len(self.index.doc_lengths)  # 用总长度除以文档数得到平均长度  

def search(self, query, top_k=10):  # 定义搜索方法，输入查询字符串与返回结果的数量上限  

    tokens = self.preprocessor.tokenize(query)  # 对查询语句进行分词和停用词过滤，得到有效词列表  

    scores = defaultdict(float)  # 使用defaultdict存储文档得分，默认初始值为0.0便于累加  

    for term in tokens:  # 遍历查询中的每个词项  

        postings = self.index.index.get(term)  # 从倒排索引中获取该词对应的文档记录集合  

        if not postings:  # 若该词不在任何文档中出现，则跳过  

            continue  # 进行下一词项处理  

        for doc_id, info in postings.items():  # 遍历该词在不同文档中的记录  

            tf = info["tf"]  # 获取该词在当前文档中的出现次数  

            scores[doc_id] += tf_weight * idf_value  # 将该词对该文档的贡献加到文档总得分上  

    ranked = sorted(scores.items(), key=lambda x: x[1], reverse=True)  # 将文档按得分从高到低排序得到排名列表  

    results = []  # 初始化结果列表，用于存放结构化的搜索结果条目  

    for doc_id, score in ranked[:top_k]:  # 遍历前top_k条文档得分记录  

        meta = self.index.doc_meta.get(doc_id, {})  # 获取该文档的元数据，如标题和URL等  

            "title": meta.get("title", ""),  # 从元数据中获取标题，若不存在则为空字符串  

            "url": meta.get("url"),  # 从元数据中获取原始新闻链接地址  

            "score": score  # 保存该文档的相关性得分，便于客户端展示或分析  

    return results  # 返回完整的搜索结果列表  

BM25评分模型与检索模块示例

def _compute_avg_doc_length(self):  # 内部方法，用于计算平均文档长度  

    if not self.index.doc_lengths:  # 若当前没有任何文档长度记录  

        return 0.0  # 返回0表示平均长度不可用  

    total_len = sum(self.index.doc_lengths.values())  # 累加所有文档长度得到总长度  

def bm25_score(self, tf, doc_len, idf_value):  # 定义BM25单词项得分计算函数  

    numerator = tf * (self.k1 + 1)  # 计算分子部分，将词频乘以k1+1增强作用  

    denominator = tf + self.k1 * (1 - self.b + self.b * (doc_len / self.avg_doc_len + 1e-9))  # 计算分母，综合词频和长度归一项并添加微小常数防止除零  

    return idf_value * (numerator / denominator)  # 返回BM25得分，IDF与TF加权比值的乘积  

    tokens = self.preprocessor.tokenize(query)  # 对查询文本进行分词，得到关键词列表  

    for term in tokens:  # 遍历每个查询词项  

        postings = self.index.index.get(term)  # 从倒排索引中取出该词的文档记录  

        if not postings:  # 若该词在索引中不存在  

            continue  # 跳过当前词  

        for doc_id, info in postings.items():  # 遍历该词对应的各文档信息  

            tf = info["tf"]  # 获取该词在当前文档中的词频  

            doc_len = self.index.doc_lengths.get(doc_id, 0)  # 获取当前文档长度，若不存在则视为0  

            score_increment = self.bm25_score(tf, doc_len, idf_value)  # 调用bm25_score计算这对词与文档的得分贡献  

            if "title" in info["fields"]:  # 若该词出现在标题字段中  

                score_increment *= 1.2  # 适当放大该词对总分的贡献，体现标题的更高权重  

            scores[doc_id] += score_increment  # 将当前词对该文档的贡献累加到总得分中  

    ranked = sorted(scores.items(), key=lambda x: x[1], reverse=True)  # 按得分从高到低排序得到文档排名  

    results = []  # 初始化搜索结果列表  

    for doc_id, score in ranked[:top_k]:  # 取前top_k个高分文档进行封装  

        meta = self.index.doc_meta.get(doc_id, {})  # 从文档元数据表中获取当前文档的基本信息  

        results.append({  # 构造单条搜索结果记录  

            "doc_id": doc_id,  # 保存文档ID  

            "title": meta.get("title", ""),  # 保存文档标题文本  

        })  # 完成单条结果结构化  

    return results  # 返回完整的BM25搜索结果列表  

简单查询接口与结果摘要生成模块示例

class SimpleSearchService: # 定义简易搜索服务类，用于整合搜索器与结果加工逻辑
def init(self, searcher, preprocessor, index): # 初始化方法，接收搜索器、预处理器与倒排索引
self.searcher = searcher # 保存具体搜索器实例，可以是TF-IDF或BM25搜索器
self.preprocessor = preprocessor # 保存文本预处理器实例，用于查询和摘要相关处理
self.index = index # 保存倒排索引实例，用于根据文档ID取回原始内容

    title = meta.get("title", "")  # 从元数据中读取标题文本，若无则为空字符串  

    clean_title = self.preprocessor.clean_text(title)  # 对标题进行清洗，移除潜在标签与冗余空白  

    if len(clean_title) <= snippet_length:  # 若标题长度不超过预期摘要长度  

        return clean_title  # 直接返回整段标题作为摘要  

    return clean_title[:snippet_length] + "..."  # 若标题较长则截取指定长度并添加省略号  

def search_with_snippets(self, query, top_k=10):  # 定义带摘要生成的搜索方法  

    raw_results = self.searcher.search(query, top_k=top_k)  # 调用底层搜索器执行查询获取原始结果列表  

    enhanced_results = []  # 初始化增强结果列表，将在原始结果基础上附加摘要信息  

    for item in raw_results:  # 遍历每条原始结果记录  

        doc_id = item["doc_id"]  # 取出当前记录的文档ID  

        snippet = self.make_snippet(doc_id, query)  # 调用make_snippet生成该文档的摘要文本  

        new_item = dict(item)  # 复制原始结果字典，避免直接修改原对象  

        new_item["snippet"] = snippet  # 在新字典中添加摘要字段  

        enhanced_results.append(new_item)  # 将增强后的结果条目添加到结果列表中  

return enhanced_results  # 返回包含摘要的完整搜索结果集合  

更多详细内容请访问

http://【自然语言处理】基于Python的新闻搜索引擎设计与实现：面向垂直领域的信息检索系统开发基于Python的新闻搜索引擎设计与实现的详细项目实例（含完整的程序，数据库和GUI设计，代码详解）_带GUI的时间序列预测项目资源-CSDN下载  https://download.csdn.net/download/xiaoxingkongyuxi/90241685

https://download.csdn.net/download/xiaoxingkongyuxi/90241685

https://download.csdn.net/download/xiaoxingkongyuxi/90241685