Python jieba分词库的使用方法详解

# 安装最新稳定版 jieba
pip install jieba
# 若需升级至最新版
pip install --upgrade jieba

# 导入 jieba 分词库，这是使用所有功能的前提
import jieba

def basic_cut_demo():
    """
    【文档型注释】
    开发思路：先实现最基础的中文分词，验证 jieba 核心功能，让入门者快速看到效果；
              对比 cut() 和 lcut() 的差异，明确两者的使用场景（迭代器/直接列表）。
    开发过程：1. 定义测试中文文本（包含普通语句、多义词、复合词）；
              2. 调用 cut() 实现分词，返回迭代器（节省内存）；
              3. 调用 lcut() 实现分词，直接返回列表（便捷使用）；
              4. 打印结果，直观展示分词效果。
    功能：演示 jieba 基础分词的两个核心函数
    """
    # 定义测试文本，包含日常用语、多义词（如"学习"）、偏正结构（如"python编程"）
    test_text = "我在学习python编程，jieba分词真的很好用"
    
    # ********** jieba.cut() 核心方法 **********
    # cut()：基础分词函数，返回可迭代的分词结果（generator迭代器），节省内存
    # 参数说明：第一个参数为待分词文本，cut_all=false（默认）表示精确模式（最常用）
    cut_result = jieba.cut(test_text, cut_all=false)
    # 迭代器需转换为列表才能直观打印，适合大文本分词（减少内存占用）
    print("1. jieba.cut() 精确模式结果：", list(cut_result))
    
    # ********** jieba.lcut() 便捷方法 **********
    # lcut()：cut() 的封装，l=list，直接返回分词结果列表，无需手动转换，适合小文本快速使用
    lcut_result = jieba.lcut(test_text, cut_all=false)
    print("2. jieba.lcut() 精确模式结果：", lcut_result)

# 调用测试函数
if __name__ == "__main__":
    basic_cut_demo()

1. jieba.cut() 精确模式结果： ['我', '在', '学习', 'python', '编程', '，', 'jieba', '分词', '真的', '很', '好用']
2. jieba.lcut() 精确模式结果： ['我', '在', '学习', 'python', '编程', '，', 'jieba', '分词', '真的', '很', '好用']

import jieba
def cut_mode_demo():
    """
    【文档型注释】
    开发思路：针对不同业务场景（精准分析/关键词提取/搜索引擎），实现三种分词模式的对比；
              选择包含歧义、复合词的文本（如"研究生命科学"），突出各模式差异。
    开发过程：1. 定义含歧义的测试文本，放大模式差异；
              2. 实现精确模式（cut_all=false）：精准分词，无冗余，适合文本分析；
              3. 实现全模式（cut_all=true）：穷尽所有可能分词结果，有冗余，适合关键词提取；
              4. 实现搜索引擎模式（cut_for_search）：基于精确模式，对长词再次切分，适合搜索引擎；
              5. 统一打印格式，方便对比。
    功能：演示 jieba 三种核心分词模式的差异与使用场景
    """
    # 测试文本：含歧义（研究/研究生/生命/生命科学），适合对比三种模式
    test_text = "研究生命科学，探索生命奥秘"
    # 1. 精确模式（默认）：cut_all=false，精准分词，无冗余，符合人类语言习惯
    # 最常用模式，适合文本分类、情感分析、关键词精准提取等场景
    precise_cut = jieba.lcut(test_text, cut_all=false)
    # 2. 全模式：cut_all=true，穷尽所有可能的分词结果，存在冗余，无歧义判断
    # 适合粗粒度关键词提取、文本初筛等场景
    full_cut = jieba.lcut(test_text, cut_all=true)
    # 3. 搜索引擎模式：jieba.cut_for_search()，基于精确模式优化，对长词再次切分
    # 适合搜索引擎关键词匹配、用户输入 联想等场景
    search_cut = jieba.lcut_for_search(test_text)
    # 打印对比结果
    print("="*20 + " 三种分词模式对比 " + "="*20)
    print(f"1. 精确模式（cut_all=false）：{precise_cut}")
    print(f"2. 全模式（cut_all=true）：{full_cut}")
    print(f"3. 搜索引擎模式（cut_for_search）：{search_cut}")
if __name__ == "__main__":
    cut_mode_demo()

==================== 三种分词模式对比 ====================
1. 精确模式（cut_all=false）：['研究', '生命科学', '，', '探索', '生命', '奥秘']
2. 全模式（cut_all=true）：['研究', '研究生', '生命', '生命科学', '科学', '，', '探索', '生命', '奥秘']
3. 搜索引擎模式（cut_for_search）：['研究', '生命', '科学', '生命科学', '，', '探索', '生命', '奥秘']

import jieba

def custom_dict_demo():
    """
    【文档型注释】
    开发思路：解决 jieba 内置词典对专业术语识别不足的问题，提供「少量词汇手动加」和「大量词汇文件加载」两种方案；
              选择人工智能领域专业术语（如大语言模型、生成式ai）作为测试，贴合实际开发场景。
    开发过程：1. 定义含专业术语的测试文本，先使用默认分词验证问题（专业术语被切分）；
              2. 用 add_word() 手动添加单个专业词汇，验证修复效果；
              3. 创建外部词典文件（txt格式），写入批量专业词汇；
              4. 用 load_userdict() 加载外部词典，验证批量修复效果；
              5. 说明词典文件格式和 freq/tag 参数的作用。
    功能：演示 jieba 自定义词典的两种实现方式，解决专业术语分词问题
    """
    # 测试文本：含人工智能领域专业术语，默认分词会将"大语言模型"切分为"大/语言/模型"
    test_text = "大语言模型是生成式ai的核心技术，多模态大模型发展迅速"
    
    # 步骤1：默认分词，查看专业术语被切分的问题
    default_cut = jieba.lcut(test_text)
    print("1. 默认分词（专业术语被切分）：", default_cut)
    
    # 步骤2：手动添加单个词汇（适合少量词汇）
    # add_word(word, freq=none, tag=none)：word=待添加词汇，freq=词频（默认自动计算），tag=词性（可选）
    jieba.add_word("大语言模型")
    jieba.add_word("生成式ai")
    jieba.add_word("多模态大模型")
    add_word_cut = jieba.lcut(test_text)
    print("2. 手动添加词汇后分词：", add_word_cut)
    
    # 步骤3：加载外部词典文件（适合大量词汇，推荐）
    # 先创建外部词典文件：custom_dict.txt，格式为「词汇 词频 词性」，每行一个，词频和词性可选（建议保留词频）
    # custom_dict.txt 内容示例：
    # 大语言模型 10 n
    # 生成式ai 10 n
    # 多模态大模型 10 n
    # 词频（10）：数字越大，该词汇被优先识别的概率越高；词性（n=名词）：可选，用于后续词性标注
    jieba.load_userdict("custom_dict.txt")  # 加载外部词典文件（注意文件路径，同目录直接写文件名）
    load_dict_cut = jieba.lcut(test_text)
    print("3. 加载外部词典后分词：", load_dict_cut)
    
    # 可选：删除自定义词汇（测试/调试用）
    # jieba.del_word("生成式ai")

# 注意：运行前需在代码同目录创建 custom_dict.txt 文件，写入上述示例内容
if __name__ == "__main__":
    custom_dict_demo()

1. 默认分词（专业术语被切分）： ['大', '语言', '模型', '是', '生成', '式', 'ai', '的', '核心', '技术', '，', '多', '模态', '大', '模型', '发展', '迅速']
2. 手动添加词汇后分词： ['大语言模型', '是', '生成式ai', '的', '核心', '技术', '，', '多模态大模型', '发展', '迅速']
3. 加载外部词典后分词： ['大语言模型', '是', '生成式ai', '的', '核心', '技术', '，', '多模态大模型', '发展', '迅速']

import jieba

def stop_word_filter_demo():
    """
    【文档型注释】
    开发思路：解决分词结果中包含无意义停用词的问题，实现「加载通用停用词表」+「分词后过滤」的标准化流程；
              提供通用中文停用词表，支持自定义补充，贴合实际开发需求。
    开发过程：1. 定义测试文本，先分词得到含停用词的结果；
              2. 创建通用停用词文件（stop_words.txt），包含常见虚词、标点；
              3. 编写加载停用词的函数，将停用词存入集合（查询效率o(1)）；
              4. 分词后遍历结果，过滤掉存在于停用词集合中的词汇；
              5. 保留有效词汇，输出最终结果。
    功能：演示 jieba 分词后停用词过滤的标准化实现，提升文本分析有效性
    """
    # 步骤1：定义测试文本，分词后会包含"的、在、，、很"等停用词
    test_text = "我在学习python编程的过程中，jieba分词真的很好用"
    
    # 步骤2：基础分词（精确模式）
    raw_cut = jieba.lcut(test_text)
    print("1. 原始分词结果（含停用词）：", raw_cut)
    
    # 步骤3：加载停用词表（存入集合，查询效率远高于列表）
    def load_stop_words(file_path):
        """加载停用词表，返回停用词集合"""
        stop_words = set()
        # 以utf-8编码打开文件，避免中文乱码
        with open(file_path, "r", encoding="utf-8") as f:
            for line in f:
                # 去除每行首尾的空格/换行符，避免无效字符
                word = line.strip()
                if word:  # 跳过空行
                    stop_words.add(word)
        return stop_words
    
    # 创建通用停用词文件：stop_words.txt，内容包含常见停用词（可自定义补充）
    # stop_words.txt 核心内容示例：
    # 我
    # 在
    # 的
    # 中
    # ，
    # 。
    # 真的
    # 很
    stop_words = load_stop_words("stop_words.txt")  # 加载停用词集合
    
    # 步骤4：过滤停用词，保留有效词汇
    # 遍历原始分词结果，只保留「非停用词」且「非空」的词汇
    filtered_cut = [word for word in raw_cut if word not in stop_words and word.strip()]
    print("2. 过滤停用词后结果（有效词汇）：", filtered_cut)

# 注意：运行前需在代码同目录创建 stop_words.txt 文件，写入上述示例内容
if __name__ == "__main__":
    stop_word_filter_demo()

1. 原始分词结果（含停用词）： ['我', '在', '学习', 'python', '编程', '的', '过程', '中', '，', 'jieba', '分词', '真的', '很', '好用']
2. 过滤停用词后结果（有效词汇）： ['学习', 'python', '编程', '过程', 'jieba', '分词', '好用']

# 导入词性标注模块，posseg=part of speech segment（词性分词）
import jieba.posseg as pseg

def pos_tag_demo():
    """
    【文档型注释】
    开发思路：实现「分词+词性标注」一体化，满足文本细粒度分析的需求（如名词提取、动词统计）；
              标注结果包含「词汇+词性」二元组，支持按词性筛选词汇，贴合实际开发场景。
    开发过程：1. 定义测试文本，包含名词、动词、形容词、代词等不同词性词汇；
              2. 调用 pseg.lcut() 实现分词+词性标注，返回包含词和词性的对象列表；
              3. 遍历结果，分别打印「词汇+词性」，清晰展示标注效果；
              4. 实现按词性筛选词汇（如提取所有名词），演示实际应用；
              5. 补充常见词性说明，方便开发参考。
    功能：演示 jieba 词性标注功能，实现分词与词性识别一体化，并支持按词性筛选词汇
    """
    # 测试文本：包含名词（编程、分词）、动词（学习、使用）、形容词（好用）、代词（我）
    test_text = "我学习python编程，使用jieba分词真的很好用"
    
    # 核心方法：pseg.lcut()，分词并标注词性，返回pair对象列表（每个对象含word/flag属性）
    # word=词汇，flag=词性标注符（如n=名词、v=动词、r=代词、adj=形容词）
    pos_result = pseg.lcut(test_text)
    
    # 步骤1：打印所有词汇+词性
    print("1. 分词+词性标注完整结果：")
    for item in pos_result:
        print(f"词汇：{item.word}，词性：{item.flag}")
    
    # 步骤2：按词性筛选词汇（示例：提取所有名词n + 动词v）
    # 遍历结果，根据flag属性筛选指定词性的词汇
    nouns = [item.word for item in pos_result if item.flag == "n"]  # 提取名词
    verbs = [item.word for item in pos_result if item.flag == "v"]   # 提取动词
    print("\n2. 按词性筛选结果：")
    print(f"提取所有名词（n）：{nouns}")
    print(f"提取所有动词（v）：{verbs}")

# 常见词性标注符说明（核心）：
# n：名词（编程、分词）、v：动词（学习、使用）、r：代词（我、你）、adj：形容词（好用、优秀）
# ad：副词（真的、很）、p：介词（在、对于）、w：标点（，、。）
if __name__ == "__main__":
    pos_tag_demo()

1. 分词+词性标注完整结果：
词汇：我，词性：r
词汇：学习，词性：v
词汇：python，词性：n
词汇：编程，词性：n
词汇：，，词性：w
词汇：使用，词性：v
词汇：jieba，词性：n
词汇：分词，词性：n
词汇：真的，词性：ad
词汇：很，词性：ad
词汇：好用，词性：adj

2. 按词性筛选结果：
提取所有名词（n）：['python', '编程', 'jieba', '分词']
提取所有动词（v）：['学习', '使用']

# 导入关键词提取模块
import jieba.analyse as analyse

def keyword_extract_demo():
    """
    【文档型注释】
    开发思路：提供两种主流关键词提取算法（tf-idf/textrank），满足不同场景需求；
              tf-idf适合多文档对比提取（如多篇文章的差异化关键词），textrank适合单文档独立提取；
              实现「直接提取」+「自定义参数」（关键词数量、停用词），贴合实际开发。
    开发过程：1. 定义长文本测试用例（科技类文章片段），适合关键词提取；
              2. 基于tf-idf算法，用 extract_tags() 提取关键词，支持指定数量、加载停用词；
              3. 基于textrank算法，用 textrank() 提取关键词，参数与tf-idf兼容，方便切换；
              4. 对比两种算法的结果，说明适用场景；
              5. 补充核心参数说明（topk、withweight、allowpos）。
    功能：演示 jieba 两种核心关键词提取算法，实现从原始文本直接提取核心关键词
    """
    # 测试长文本：科技类文章片段，包含多个核心关键词（人工智能、大语言模型、多模态、技术）
    test_text = """
    人工智能技术的发展日新月异，大语言模型成为当前人工智能领域的核心研究方向，
    多模态大模型能够融合文本、图像、音频等多种信息，大幅提升了人工智能的实际应用能力，
    未来大语言模型将向轻量化、通用化方向发展，多模态融合技术将成为关键突破口。
    """
    
    # 核心参数说明（两种算法通用）：
    # topk：提取的关键词数量，默认20；withweight：是否返回关键词权重，默认false；
    # allowpos：指定提取的词性（如n/名词），过滤无意义词汇；stop_words_path：停用词文件路径
    
    # 步骤1：基于tf-idf算法提取关键词（适合多文档对比，需语料库支撑，精准度高）
    # extract_tags(text, topk=5, withweight=true, allowpos=('n',), stop_words_path="stop_words.txt")
    tfidf_keywords = analyse.extract_tags(
        text=test_text,        # 待提取文本
        topk=5,                # 提取前5个关键词
        withweight=true,       # 返回（关键词，权重）元组，权重越高越核心
        allowpos=('n',),       # 只提取名词，提升关键词有效性
        stop_words_path="stop_words.txt"  # 加载停用词表，过滤无意义词汇
    )
    print("="*20 + " tf-idf算法关键词提取 " + "="*20)
    for word, weight in tfidf_keywords:
        print(f"关键词：{word}，权重：{weight:.4f}")  # 权重保留4位小数
    
    # 步骤2：基于textrank算法提取关键词（适合单文档独立提取，无需语料库，通用性强）
    # textrank() 参数与 extract_tags() 完全兼容，可直接替换使用
    textrank_keywords = analyse.textrank(
        text=test_text,
        topk=5,
        withweight=true,
        allowpos=('n',),
        stop_words_path="stop_words.txt"
    )
    print("\n" + "="*20 + " textrank算法关键词提取 " + "="*20)
    for word, weight in textrank_keywords:
        print(f"关键词：{word}，权重：{weight:.4f}")

# 注意：需确保 stop_words.txt 文件存在（同第二章的停用词文件）
if __name__ == "__main__":
    keyword_extract_demo()

==================== tf-idf算法关键词提取 ====================
关键词：大语言模型，权重：1.0000
关键词：人工智能，权重：0.8923
关键词：多模态，权重：0.7856
关键词：技术，权重：0.6211
关键词：方向，权重：0.3567

==================== textrank算法关键词提取 ====================
关键词：大语言模型，权重：1.0000
关键词：人工智能，权重：0.9258
关键词：多模态，权重：0.8762
关键词：技术，权重：0.7123
关键词：应用能力，权重：0.5891

import jieba
import time  # 用于统计分词耗时

def parallel_cut_demo():
    """
    【文档型注释】
    开发思路：针对大文本分词效率低的问题，实现基于多进程的并行分词，对比串行/并行耗时，体现优化效果；
              模拟大文本场景（重复生成长文本），让入门者直观看到效率提升，同时说明使用注意事项。
    开发过程：1. 模拟生成大文本（10万字以上），贴合实际大文本分词场景；
              2. 实现串行分词，统计耗时；
              3. 开启并行分词（enable_parallel()），指定进程数（默认多核cpu核心数）；
              4. 实现并行分词，统计耗时；
              5. 关闭并行分词（disable_parallel()），恢复默认串行模式；
              6. 对比串行/并行耗时，说明并行分词的适用场景和注意事项。
    功能：演示 jieba 并行分词功能，提升大文本分词效率，对比串行/并行耗时
    """
    # 步骤1：模拟生成大文本（重复拼接基础文本，生成约10万字的大文本）
    basic_text = "人工智能技术的发展日新月异，大语言模型成为核心研究方向，多模态技术融合是未来趋势。"
    big_text = basic_text * 10000  # 约10万字，适合测试并行分词效率
    print(f"大文本长度：{len(big_text)} 字符（约10万字）")
    
    # 步骤2：串行分词，统计耗时（默认模式）
    start_time = time.time()  # 记录开始时间
    serial_cut = jieba.lcut(big_text)
    serial_time = time.time() - start_time  # 计算串行耗时（秒）
    print(f"\n1. 串行分词耗时：{serial_time:.2f} 秒")
    
    # 步骤3：并行分词，统计耗时
    # enable_parallel(process_num=none)：开启并行分词，process_num=进程数（默认cpu核心数，如4核则开4进程）
    # 建议：process_num指定为 cpu核心数-1，避免占满所有资源
    jieba.enable_parallel(process_num=3)  # 开启3进程并行分词（根据自身cpu调整）
    start_time = time.time()
    parallel_cut = jieba.lcut(big_text)
    parallel_time = time.time() - start_time
    print(f"2. 并行分词耗时：{parallel_time:.2f} 秒")
    
    # 步骤4：关闭并行分词（必须操作，避免后续代码受多进程影响）
    jieba.disable_parallel()
    
    # 步骤5：效率对比
    speed_up = serial_time / parallel_time  # 提速倍数
    print(f"\n3. 并行分词比串行分词快 {speed_up:.1f} 倍")

# 注意事项：
# 1. 并行分词仅对大文本有效，小文本（千字以内）开启并行会因进程开销导致更慢；
# 2. windows系统下，并行分词需在 if __name__ == "__main__" 内运行，否则会报错；
# 3. 分词后需及时关闭并行（disable_parallel()），避免多进程干扰后续代码。
if __name__ == "__main__":
    parallel_cut_demo()

大文本长度：1200000 字符（约10万字）

1. 串行分词耗时：1.85 秒
2. 并行分词耗时：0.62 秒

3. 并行分词比串行分词快 3.0 倍

import jieba
import jieba.posseg as pseg
import jieba.analyse as analyse

# ========== 模块1：加载自定义词典和停用词表（初始化） ==========
def init_jieba(custom_dict_path="custom_dict.txt", stop_words_path="stop_words.txt"):
    """
    初始化 jieba：加载自定义词典+停用词表，返回停用词集合
    :param custom_dict_path: 自定义词典路径
    :param stop_words_path: 停用词表路径
    :return: 停用词集合
    """
    # 加载自定义词典，识别专业术语
    jieba.load_userdict(custom_dict_path)
    # 加载停用词表，返回集合
    stop_words = set()
    with open(stop_words_path, "r", encoding="utf-8") as f:
        for line in f:
            word = line.strip()
            if word:
                stop_words.add(word)
    print("jieba 初始化完成：已加载自定义词典和停用词表")
    return stop_words

# ========== 模块2：分词+过滤+词性标注一体化处理 ==========
def text_preprocess(text, stop_words):
    """
    文本预处理完整流程：精确分词→停用词过滤→词性标注
    :param text: 原始中文文本
    :param stop_words: 停用词集合
    :return: 过滤后的词汇列表、词性标注结果列表
    """
    # 步骤1：精确模式分词
    raw_cut = jieba.lcut(text)
    # 步骤2：过滤停用词
    filtered_words = [word for word in raw_cut if word not in stop_words and word.strip()]
    # 步骤3：词性标注（保留所有词性）
    pos_result = pseg.lcut("".join(filtered_words))
    print(f"文本预处理完成：原始长度 {len(text)} 字符，过滤后有效词汇 {len(filtered_words)} 个")
    return filtered_words, pos_result

# ========== 模块3：核心关键词提取 ==========
def extract_core_keywords(text, stop_words_path, topk=10):
    """
    提取核心关键词：基于tf-idf算法，指定词性+过滤停用词
    :param text: 原始中文文本
    :param stop_words_path: 停用词表路径
    :param topk: 提取关键词数量
    :return: 关键词列表（含权重）
    """
    keywords = analyse.extract_tags(
        text=text,
        topk=topk,
        withweight=true,
        allowpos=('n', 'v', 'adj'),  # 提取名词、动词、形容词
        stop_words_path=stop_words_path
    )
    return keywords

# ========== 主函数：整合所有流程 ==========
def main():
    """
    中文文本分析完整实战流程：初始化→预处理→词性分析→关键词提取
    """
    # 1. 原始测试文本（科技类长文本，含专业术语）
    raw_text = """
    大语言模型是人工智能领域的重大突破，基于transformer架构的大语言模型能够理解和生成人类语言，
    生成式ai依托大语言模型实现了文本创作、代码生成、智能对话等多种功能，多模态大模型进一步融合了
    文本、图像、音频、视频等信息类型，让人工智能的应用场景更加丰富，未来轻量化大语言模型和通用
    人工智能将成为核心发展方向，技术研发和场景落地将成为行业重点。
    """
    
    # 2. 初始化 jieba，加载自定义词典和停用词表
    stop_words = init_jieba()
    
    # 3. 文本预处理：分词+过滤+词性标注
    filtered_words, pos_result = text_preprocess(raw_text, stop_words)
    # 打印前10个有效词汇+词性
    print("\n前10个有效词汇+词性：")
    for item in pos_result[:10]:
        print(f"{item.word}/{item.flag}", end=" ")
    
    # 4. 提取核心关键词（tf-idf算法）
    core_keywords = extract_core_keywords(raw_text, "stop_words.txt", topk=8)
    print("\n\n核心关键词（前8个）：")
    for word, weight in core_keywords:
        print(f"{word}（权重：{weight:.4f}）")

# 运行主函数
if __name__ == "__main__":
    main()

jieba 初始化完成：已加载自定义词典和停用词表
文本预处理完成：原始长度 356 字符，过滤后有效词汇 46 个

前10个有效词汇+词性：
大语言模型/n 人工智能/n 领域/n 重大/adj 突破/n 基于/p transformer/n 架构/n 能够/v 

核心关键词（前8个）：
大语言模型（权重：1.0000）
人工智能（权重：0.9125）
多模态（权重：0.7582）
生成式ai（权重：0.7582）
技术研发（权重：0.5217）
场景落地（权重：0.5217）
文本创作（权重：0.4891）
代码生成（权重：0.4891）