NPL系列之分词和分词框架(二)

如果要从事NPL的相关技术工作，那么最基础的工作就是分词工作,这个也是所有技术的第一步,当然 这里讨论的中文的分词,因为英文的分词技术是比较单一,基本上按照空格进行标准分词就可以了,但是中文就比较复杂了，所以今天就一起简单的学习一下NPL的基础工作之分词技术和对应的分词开源框架

尽管中文的分词是比较复杂的,但是目前还是有很多的开源框架给开发者使用,目前开源的分词器有下面这些,但是有的如果用的商用的话,可能是需要收费的.所以要注意,像word,ansj,stanford,hanlp,jibea,foundnlp,jcseg,mmse4j,ik,paoding,smartcn,不过可以分为两大类,一大类是之提供分词相关的功能,还有一大类是分词只是基础,还提供和自然语言处理相关的功能:

& 提供分词分词相关的功能

>>mmse4j,ik,smartcn,paoding,ansj

& 提供自然语言处理相关的功能(肯定包括分词相关的功能)

>>jibea,hanlp,stanfor,foundnlp,jcseg

接下来,介绍一下每个分词器的功能

MMSE4J:

优点：

• 采用了特有的“正向迭代最细粒度切分算法”，具有60万字/秒的高速处理能力。

• 采用了多子处理器分析模式，支持：英文字母（IP地址、Email、URL）、数字（日期，常用中文数量词，罗马数字，科学计数法），中文词汇（姓名、地名处理）等分词处理。

• 优化的词典存储，更小的内存占用。支持用户词典扩展定义。

• 针对Lucene全文检索优化的查询分析器IKQueryParser，采用歧义分析算法优化查询关键字的搜索排列组合，能极大的提高Lucene检索的命中率。

IK:

算法：基于正向匹配

功能：支持smart和非smart模式

SMARTCN:

算法：基于最短路径

功能：简化版的中科院Java

缺点：不支持动态字典的扩展

PAODING:

优点：

• 高扩展性：能非常方便的扩充字典，也可以非常方便的添加停用词。

• 效率极高-极高效率的字典查找算法；尽量避免无谓试探查找。 

• 算法简练-简单易理解的算法，但效率却是非常高效的。

• 轻松支持最大/最小切词。 

缺点：

• 分词精确度不好，涉及了汉语语义的问题，几乎不可完全解决。如：“和服”实例。

ANSJ:

这是一个基于n-Gram+CRF+HMM的中文分词的java实现.

分词速度达到每秒钟大约200万字左右（mac air下测试），准确率能达到96%以上

目前实现了.中文分词. 中文姓名识别 . 用户自定义词典,关键字提取，自动摘要，关键字标记等功能

可以应用到自然语言处理等方面,适用于对分词效果要求高的各种项目.

JCSEG:

• 中文分词：mmseg算法 + Jcseg 独创的优化算法，四种切分模式。
• 关键字提取：基于textRank算法。
• 关键短语提取：基于textRank算法。
• 关键句子提取：基于textRank算法。
• 文章自动摘要：基于BM25+textRank算法。
• 自动词性标注：基于词库+（统计歧义去除计划），目前效果不是很理想，对词性标注结果要求较高的应用不建议使用。
• 命名实体标注：基于词库+（统计歧义去除计划），电子邮件，网址，大陆手机号码，地名，人名，货币，datetime时间，长度，面积，距离单位等。
• Restful api：嵌入jetty提供了一个绝对高性能的server模块，包含全部功能的http接口，标准化json输出格式，方便各种语言客户端直接调用

JIBEA:

• 支持三种分词模式：

  • 精确模式，试图将句子最精确地切开，适合文本分析-关键字提取,文本摘要获取；
  • 全模式，把句子中所有的可以成词的词语都扫描出来, 速度非常快，但是不能解决歧义；
  • 搜索引擎模式，在精确模式的基础上，对长词再次切分，提高召回率，适合用于搜索引擎分词。

• 支持繁体分词

• 支持自定义词典

HANLP:

• 中文分词
  • HMM-Bigram（速度与精度最佳平衡；一百兆内存）
    • 最短路分词、N-最短路分词
  • 由字构词（侧重精度，可识别新词；适合NLP任务）
    • 感知机分词、CRF分词
  • 词典分词（侧重速度，每秒数千万字符；省内存）
    • 极速词典分词
  • 所有分词器都支持：
    • 索引全切分模式
    • 用户自定义词典
    • 兼容繁体中文
    • 训练用户自己的领域模型
• 词性标注
  • HMM词性标注（速度快）
  • 感知机词性标注、CRF词性标注（精度高）
• 命名实体识别
  • 基于HMM角色标注的命名实体识别 （速度快）
    • 中国人名识别、音译人名识别、日本人名识别、地名识别、实体机构名识别
  • 基于线性模型的命名实体识别（精度高）
    • 感知机命名实体识别、CRF命名实体识别
• 关键词提取
  • TextRank关键词提取
• 自动摘要
  • TextRank自动摘要
• 短语提取
  • 基于互信息和左右信息熵的短语提取
• 拼音转换
  • 多音字、声母、韵母、声调
• 简繁转换
  • 简繁分歧词（简体、繁体、臺灣正體、香港繁體）
• 文本推荐
  • 语义推荐、拼音推荐、字词推荐
• 依存句法分析
  • 基于神经网络的高性能依存句法分析器
  • MaxEnt依存句法分析
• 文本分类
  • 情感分析
• word2vec
  • 词向量训练、加载、词语相似度计算、语义运算、查询、KMeans聚类
  • 文档语义相似度计算

WORD:

一个Java实现的分布式的中文分词组件，提供了多种基于词典的分词算法，并利用ngram模型来消除歧义。能准确识别英文、数字，以及日期、时间等数量词，能识别人名、地名、组织机构名等未登录词。能通过自定义配置文件来改变组件行为，能自定义用户词库、自动检测词库变化、支持大规模分布式环境，能灵活指定多种分词算法，能使用refine功能灵活控制分词结果，还能使用词频统计、词性标注、同义标注、反义标注、拼音标注等功能。提供了10种分词算法，还提供了10种文本相似度算法，同时还无缝和Lucene、Solr、ElasticSearch、Luke集成。注意：

FOUNDNLP:一个Java本报实现的分词组件,除分词功能之外,也支持自然语言处理相关的功能.关键字提取,生成自动摘要

STANFORENLP:和上面类似,都是除分词之外还提供一些和自然语言处理相关的功能:

上面就把常用的分词组件进行了简单的介绍,因为只要知道每种功能是做什么以及对应的缺点,才能为业务开发做选性支撑,为了看真实的效果,可以把上面的分词器进行封装,然后统一测试:

首先定义一个接口:

/**
 * 获取文本的所有分词结果, 对比不同分词器结果
 */
public interface WordSegmenter {
    /**
     * 获取文本的所有分词结果
     * @param text 文本
     * @return 所有的分词结果，去除重复
     */
    default public Set seg(String text) {
        return segMore(text).values().stream().collect(Collectors.toSet());
    }
    /**
     * 获取文本的所有分词结果
     * @param text 文本
     * @return 所有的分词结果，KEY 为分词器模式，VALUE 为分词器结果
     */
    public Map segMore(String text);
}

然后看下面每个分词组件的实现:

& word分词器

@Override
public Map segMore(String text) {
    Map map = new HashMap<>();
    for(SegmentationAlgorithm segmentationAlgorithm : SegmentationAlgorithm.values()){
        map.put(segmentationAlgorithm.getDes(), seg(text, segmentationAlgorithm));
    }
    return map;
}
private static String seg(String text, SegmentationAlgorithm segmentationAlgorithm) {
    StringBuilder result = new StringBuilder();
    for(Word word : WordSegmenter.segWithStopWords(text, segmentationAlgorithm)){
        result.append(word.getText()).append(" ");
    }
    return result.toString();
}

& ansj分词器

@Override
public Map segMore(String text) {
    Map map = new HashMap<>();

    StringBuilder result = new StringBuilder();
    for(Term term : BaseAnalysis.parse(text)){
        result.append(term.getName()).append(" ");
    }
    map.put("BaseAnalysis", result.toString());

    result.setLength(0);
    for(Term term : ToAnalysis.parse(text)){
        result.append(term.getName()).append(" ");
    }
    map.put("ToAnalysis", result.toString());

    result.setLength(0);
    for(Term term : NlpAnalysis.parse(text)){
        result.append(term.getName()).append(" ");
    }
    map.put("NlpAnalysis", result.toString());

    result.setLength(0);
    for(Term term : IndexAnalysis.parse(text)){
        result.append(term.getName()).append(" ");
    }
    map.put("IndexAnalysis", result.toString());

    return map;
}

& stanford分词器

private static final StanfordCoreNLP CTB = new StanfordCoreNLP("StanfordCoreNLP-chinese-ctb");
private static final StanfordCoreNLP PKU = new StanfordCoreNLP("StanfordCoreNLP-chinese-pku");
private static final PrintStream NULL_PRINT_STREAM = new PrintStream(new NullOutputStream(), false);
public Map segMore(String text) {
    Map map = new HashMap<>();
    map.put("Stanford Beijing University segmentation", seg(PKU, text));
    map.put("Stanford Chinese Treebank segmentation", seg(CTB, text));
    return map;
}
private static String seg(StanfordCoreNLP stanfordCoreNLP, String text){
    PrintStream err = System.err;
    System.setErr(NULL_PRINT_STREAM);
    Annotation document = new Annotation(text);
    stanfordCoreNLP.annotate(document);
    List sentences = document.get(CoreAnnotations.SentencesAnnotation.class);
    StringBuilder result = new StringBuilder();
    for(CoreMap sentence: sentences) {
        for (CoreLabel token: sentence.get(CoreAnnotations.TokensAnnotation.class)) {
            String word = token.get(CoreAnnotations.TextAnnotation.class);;
            result.append(word).append(" ");
        }
    }
    System.setErr(err);
    return result.toString();
}

& fudannlp分词器

private static CWSTagger tagger = null;
static{
    try{
        tagger = new CWSTagger("lib/fudannlp_seg.m");
        tagger.setEnFilter(true);
    }catch(Exception e){
        e.printStackTrace();
    }
}
@Override
public Map segMore(String text) {
    Map map = new HashMap<>();
    map.put("FudanNLP", tagger.tag(text));
    return map;
}

& jieba分词器

private static final JiebaSegmenter JIEBA_SEGMENTER = new JiebaSegmenter();
@Override
public Map segMore(String text) {
    Map map = new HashMap<>();
    map.put("INDEX", seg(text, SegMode.INDEX));
    map.put("SEARCH", seg(text, SegMode.SEARCH));
    return map;
}
private static String seg(String text, SegMode segMode) {
    StringBuilder result = new StringBuilder();                
    for(SegToken token : JIEBA_SEGMENTER.process(text, segMode)){
        result.append(token.word.getToken()).append(" ");
    }
    return result.toString(); 
}

& jcseg分词器

private static final JcsegTaskConfig CONFIG = new JcsegTaskConfig();
private static final ADictionary DIC = DictionaryFactory.createDefaultDictionary(CONFIG);
static {
    CONFIG.setLoadCJKSyn(false);
    CONFIG.setLoadCJKPinyin(false);
}
@Override
public Map segMore(String text) {
    Map map = new HashMap<>();

    map.put("复杂模式", segText(text, JcsegTaskConfig.COMPLEX_MODE));
    map.put("简易模式", segText(text, JcsegTaskConfig.SIMPLE_MODE));

    return map;
}
private String segText(String text, int segMode) {
    StringBuilder result = new StringBuilder();        
    try {
        ISegment seg = SegmentFactory.createJcseg(segMode, new Object[]{new StringReader(text), CONFIG, DIC});
        IWord word = null;
        while((word=seg.next())!=null) {         
            result.append(word.getValue()).append(" ");
        }
    } catch (Exception ex) {
        throw new RuntimeException(ex);
    }
    return result.toString();
}

& mmse4j分词器

private static final Dictionary DIC = Dictionary.getInstance();
private static final SimpleSeg SIMPLE_SEG = new SimpleSeg(DIC);
private static final ComplexSeg COMPLEX_SEG = new ComplexSeg(DIC);
private static final MaxWordSeg MAX_WORD_SEG = new MaxWordSeg(DIC);
@Override
public Map segMore(String text) {
    Map map = new HashMap<>();
    map.put(SIMPLE_SEG.getClass().getSimpleName(), segText(text, SIMPLE_SEG));
    map.put(COMPLEX_SEG.getClass().getSimpleName(), segText(text, COMPLEX_SEG));
    map.put(MAX_WORD_SEG.getClass().getSimpleName(), segText(text, MAX_WORD_SEG));
    return map;
}
private String segText(String text, Seg seg) {
    StringBuilder result = new StringBuilder();
    MMSeg mmSeg = new MMSeg(new StringReader(text), seg);        
    try {
        Word word = null;
        while((word=mmSeg.next())!=null) {       
            result.append(word.getString()).append(" ");
        }
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
    return result.toString();
}

& ik分词器

@Override
public Map segMore(String text) {
    Map map = new HashMap<>();

    map.put("智能切分", segText(text, true));
    map.put("细粒度切分", segText(text, false));

    return map;
}
private String segText(String text, boolean useSmart) {
    StringBuilder result = new StringBuilder();
    IKSegmenter ik = new IKSegmenter(new StringReader(text), useSmart);        
    try {
        Lexeme word = null;
        while((word=ik.next())!=null) {          
            result.append(word.getLexemeText()).append(" ");
        }
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
    return result.toString();
}

& paoding分词器

private static final PaodingAnalyzer ANALYZER = new PaodingAnalyzer();
@Override
public Map segMore(String text) {
    Map map = new HashMap<>();

    map.put("MOST_WORDS_MODE", seg(text, PaodingAnalyzer.MOST_WORDS_MODE));
    map.put("MAX_WORD_LENGTH_MODE", seg(text, PaodingAnalyzer.MAX_WORD_LENGTH_MODE));
    
    return map;
}
private static String seg(String text, int mode){
    ANALYZER.setMode(mode);
    StringBuilder result = new StringBuilder();
    try {
        Token reusableToken = new Token();
        TokenStream stream = ANALYZER.tokenStream("", new StringReader(text));
        Token token = null;
        while((token = stream.next(reusableToken)) != null){
            result.append(token.term()).append(" ");
        }
    } catch (Exception ex) {
        throw new RuntimeException(ex);
    }
    return result.toString();          
}

& smartcn分词器

private static final SmartChineseAnalyzer SMART_CHINESE_ANALYZER = new SmartChineseAnalyzer();
@Override
public Map segMore(String text) {
    Map map = new HashMap<>();
    map.put("smartcn", segText(text));
    return map;
}
private static String segText(String text) {
    StringBuilder result = new StringBuilder();
    try {
        TokenStream tokenStream = SMART_CHINESE_ANALYZER.tokenStream("text", new StringReader(text));
        tokenStream.reset();
        while (tokenStream.incrementToken()){
            CharTermAttribute charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
            result.append(charTermAttribute.toString()).append(" ");
        }
        tokenStream.close();
    }catch (Exception e){
        e.printStackTrace();
    }
    return result.toString();
}

& hanlp分词器

private static final Segment N_SHORT_SEGMENT = new NShortSegment().enableCustomDictionary(false).enablePlaceRecognize(true).enableOrganizationRecognize(true);
private static final Segment DIJKSTRA_SEGMENT = new DijkstraSegment().enableCustomDictionary(false).enablePlaceRecognize(true).enableOrganizationRecognize(true);
@Override
public Map segMore(String text) {
    Map map = new HashMap<>();
    map.put("标准分词", standard(text));
    map.put("NLP分词", nlp(text));
    map.put("索引分词", index(text));
    map.put("N-最短路径分词", nShort(text));
    map.put("最短路径分词", shortest(text));
    map.put("极速词典分词", speed(text));
    return map;
}
private static String standard(String text) {
    StringBuilder result = new StringBuilder();
    StandardTokenizer.segment(text).forEach(term->result.append(term.word).append(" "));
    return result.toString();
}
private static String nlp(String text) {
    StringBuilder result = new StringBuilder();
    NLPTokenizer.segment(text).forEach(term->result.append(term.word).append(" "));
    return result.toString();
}
private static String index(String text) {
    StringBuilder result = new StringBuilder();
    IndexTokenizer.segment(text).forEach(term->result.append(term.word).append(" "));
    return result.toString();
}
private static String speed(String text) {
    StringBuilder result = new StringBuilder();
    SpeedTokenizer.segment(text).forEach(term->result.append(term.word).append(" "));
    return result.toString();
}
private static String nShort(String text) {
    StringBuilder result = new StringBuilder();
    N_SHORT_SEGMENT.seg(text).forEach(term->result.append(term.word).append(" "));
    return result.toString();
}
private static String shortest(String text) {
    StringBuilder result = new StringBuilder();
    DIJKSTRA_SEGMENT.seg(text).forEach(term->result.append(term.word).append(" "));
    return result.toString();
}

写个测试类进行测试

public static Map> contrast(String text){
    Map> map = new LinkedHashMap<>();
    map.put("word分词器", new WordEvaluation().seg(text));
    map.put("Stanford分词器", new StanfordEvaluation().seg(text));
    map.put("Ansj分词器", new AnsjEvaluation().seg(text));
    map.put("HanLP分词器", new HanLPEvaluation().seg(text));
    map.put("FudanNLP分词器", new FudanNLPEvaluation().seg(text));
    map.put("Jieba分词器", new JiebaEvaluation().seg(text));
    map.put("Jcseg分词器", new JcsegEvaluation().seg(text));
    map.put("MMSeg4j分词器", new MMSeg4jEvaluation().seg(text));
    map.put("IKAnalyzer分词器", new IKAnalyzerEvaluation().seg(text));
    map.put("smartcn分词器", new SmartCNEvaluation().seg(text));
    return map;
}
public static Map> contrastMore(String text){
    Map> map = new LinkedHashMap<>();
    map.put("word分词器", new WordEvaluation().segMore(text));
    map.put("Stanford分词器", new StanfordEvaluation().segMore(text));
    map.put("Ansj分词器", new AnsjEvaluation().segMore(text));
    map.put("HanLP分词器", new HanLPEvaluation().segMore(text));
    map.put("FudanNLP分词器", new FudanNLPEvaluation().segMore(text));
    map.put("Jieba分词器", new JiebaEvaluation().segMore(text));
    map.put("Jcseg分词器", new JcsegEvaluation().segMore(text));
    map.put("MMSeg4j分词器", new MMSeg4jEvaluation().segMore(text));
    map.put("IKAnalyzer分词器", new IKAnalyzerEvaluation().segMore(text));
    map.put("smartcn分词器", new SmartCNEvaluation().segMore(text));
    return map;
}
public static void show(Map> map){
    map.keySet().forEach(k -> {
        System.out.println(k + " 的分词结果：");
        AtomicInteger i = new AtomicInteger();
        map.get(k).forEach(v -> {
            System.out.println("\t" + i.incrementAndGet() + " 、" + v);
        });
    });
}
public static void showMore(Map> map){
    map.keySet().forEach(k->{
        System.out.println(k + " 的分词结果：");
        AtomicInteger i = new AtomicInteger();
        map.get(k).keySet().forEach(a -> {
            System.out.println("\t" + i.incrementAndGet()+ " 、【"   + a + "】\t" + map.get(k).get(a));
        });
    });
}
public static void main(String[] args) {
    show(contrast("我爱楚离陌"));
    showMore(contrastMore("我爱楚离陌"));
}

看一下最终的效果:

********************************************
word分词器 的分词结果：
    1 、我 爱 楚离陌 
Stanford分词器 的分词结果：
    1 、我 爱 楚 离陌 
    2 、我 爱 楚离陌 
Ansj分词器 的分词结果：
    1 、我 爱 楚离 陌 
    2 、我 爱 楚 离 陌 
HanLP分词器 的分词结果：
    1 、我 爱 楚 离 陌 
smartcn分词器 的分词结果：
    1 、我 爱 楚 离 陌 
FudanNLP分词器 的分词结果：
    1 、我 爱楚离陌
Jieba分词器 的分词结果：
    1 、我爱楚 离 陌 
Jcseg分词器 的分词结果：
    1 、我 爱 楚 离 陌 
MMSeg4j分词器 的分词结果：
    1 、我爱 楚 离 陌 
IKAnalyzer分词器 的分词结果：
    1 、我 爱 楚 离 陌 
********************************************
********************************************
word分词器 的分词结果：
    1 、【全切分算法】    我 爱 楚离陌 
    2 、【双向最大最小匹配算法】    我 爱 楚离陌 
    3 、【正向最大匹配算法】    我 爱 楚离陌 
    4 、【双向最大匹配算法】    我 爱 楚离陌 
    5 、【逆向最大匹配算法】    我 爱 楚离陌 
    6 、【正向最小匹配算法】    我 爱 楚离陌 
    7 、【双向最小匹配算法】    我 爱 楚离陌 
    8 、【逆向最小匹配算法】    我 爱 楚离陌 
Stanford分词器 的分词结果：
    1 、【Stanford Chinese Treebank segmentation】    我 爱 楚离陌 
    2 、【Stanford Beijing University segmentation】    我 爱 楚 离陌 
Ansj分词器 的分词结果：
    1 、【BaseAnalysis】    我 爱 楚 离 陌 
    2 、【IndexAnalysis】    我 爱 楚 离 陌 
    3 、【ToAnalysis】    我 爱 楚 离 陌 
    4 、【NlpAnalysis】    我 爱 楚离 陌 
HanLP分词器 的分词结果：
    1 、【NLP分词】    我 爱 楚 离 陌 
    2 、【标准分词】    我 爱 楚 离 陌 
    3 、【N-最短路径分词】    我 爱 楚 离 陌 
    4 、【索引分词】    我 爱 楚 离 陌 
    5 、【最短路径分词】    我 爱 楚 离 陌 
    6 、【极速词典分词】    我 爱 楚 离 陌 
smartcn分词器 的分词结果：
    1 、【smartcn】    我 爱 楚 离 陌 
FudanNLP分词器 的分词结果：
    1 、【FudanNLP】    我 爱楚离陌
Jieba分词器 的分词结果：
    1 、【SEARCH】    我爱楚 离 陌 
    2 、【INDEX】    我爱楚 离 陌 
Jcseg分词器 的分词结果：
    1 、【简易模式】    我 爱 楚 离 陌 
    2 、【复杂模式】    我 爱 楚 离 陌 
MMSeg4j分词器 的分词结果：
    1 、【SimpleSeg】    我爱 楚 离 陌 
    2 、【ComplexSeg】    我爱 楚 离 陌 
    3 、【MaxWordSeg】    我爱 楚 离 陌 
IKAnalyzer分词器 的分词结果：
    1 、【智能切分】    我 爱 楚 离 陌 
    2 、【细粒度切分】    我 爱 楚 离 陌 
********************************************

从上面的结果中可以看出来hanlp支持的分词类型是最多的,最后提一点建议,就是关于如何选择和学习？

选型

1 如果当前的分词功能是为了和搜索引擎结合,比如像solr,elasticsearch,luncene等那么使用IK,MMSE4J,JIBEA即可

2 如果当前的分词功能是基础,还需要其它相关功能,比如自动文本摘要提权,关键字提权,词性识别等,那么使用hanlp,fudannlp,jibea,jcseg等

学习：(对于新手而言)

那么多的框架,肯定不需要全部掌握,但是对于常用的框架,最好能够系统性的进行掌握,比如举个列子,对于jibea而言,它提供分词,关键字提权,文本摘要生成等，尽管用它的时候,大多数都是使用分词功能,但是从学习掌握技术的全面性来说,可以把它所有的功能都掌握一下，比如像jieba常用的功能如下

#encoding=utf8
import jieba
from jieba import analyse
from jieba import posseg
# 算法介绍
#基于前缀词典实现高效的词图扫描，生成句子中汉字所有可能成词情况所构成的有向无环图 (DAG)
#采用了动态规划查找最大概率路径, 找出基于词频的最大切分组合
#对于未登录词，采用了基于汉字成词能力的 HMM 模型，使用了 Viterbi 算法

# 分词速度
#1.5 MB / Second in Full Mode
#400 KB / Second in Default Mode
#测试环境: Intel(R) Core(TM) i7-2600 CPU @ 3.4GHz；《围城》.txt

# 核心功能
# 1 基本分词演示
# 2 添加自定义字典
# 3 关键词提取
# 4 词性标注
# 5 并行分词
# 6 Tokenizer使用

# 封装jibea基础功能的演示
class JibeaFunciont():

    # 初始化方法
    def __init__(self,dictPath):

        print("init object..."+dictPath)

    # 测试基本分词使用
    def cutWord(self,str):
        print("=====================进入分词功能=====================")
        #设置并行分词 processnum=并行分词的线程数
        jieba.enable_parallel(processnum=4)
        seg_list = jieba.cut(str, cut_all=True)
        print("[全模式匹配:] " + "/ ".join(seg_list))  # 全模式

        seg_list = jieba.cut(str, cut_all=False)
        print("[精确模式匹配:] " + "/ ".join(seg_list))  # 精确模式

        seg_list = jieba.cut(str)  # 默认是精确模式
        print("[默认模式匹配:]"+",".join(seg_list))

        seg_list = jieba.cut_for_search(str)  # 搜索引擎模式
        print("[搜索引擎模式匹配:]"+",".join(seg_list))


    #加载自定义词典
    # 词典格式和 dict.txt 一样，一个词占一行；每一行分三部分：词语、词频（可省略）、词性（可省略），用空格隔开，顺序不可颠倒。
    # file_name 若为路径或二进制方式打开的文件，则文件必须为 UTF-8 编码
    def loadDict(self,str,dictPath):
        print("=====================进入加载自定义词典=====================")
        jieba.load_userdict(dictPath)
        self._fillWordFreq(dictPath)
        seg_list = jieba.cut(str,HMM=False)
        print("[全模式匹配:] " + "/ ".join(seg_list))

        #知识点补充 有时候就算使用自定义词典发现词还是没有被正确分出来 因为分词有个因子是和词频相关的 所以需要进行扩展
        # 使用 add_word(word, freq=None, tag=None) 和 del_word(word) 可在程序中动态修改词典
        # 使用 suggest_freq(segment, tune=True) 可调节单个词语的词频，使其能（或不能）被分出来

    #动态填充词典中每个词的频率
    def _fillWordFreq(self,dicPath):
        for line in open(dictPath,encoding="utf-8"):
            # 保证自定义的词典一定是不会被拆分的 能分出一个完整的词
            jieba.suggest_freq(segment=line.strip(),tune=True)
            # 从程序效率角度来说 可以用下面这行代码实现
            #[jieba.suggest_freq(line.strip(),tune=True)  for line in open(dictPath,encoding="utf-8")]

    #基于TF-IDF
    def _extractWord_TFIDF(self,str):
        tfidf = analyse.extract_tags
        words = tfidf(str)
        print("keywords by tfidf:")
        for word in words:
            print(word+"/")

    #基于TextRank
    def _extractWord_TextRank(self,str):
        textrank = analyse.textrank
        words = textrank(str)
        print("keywords by textrank:")
        for word in words:
            print(word+"/")

    # 抽取关键字 https://www.cnblogs.com/zhbzz2007/p/6177832.html
    def extractKeyWord(self,str,type):
        if(type=="tfidf"):
            self._extractWord_TFIDF(str)
        if(type=="textrank"):
            self._extractWord_TextRank(str)
        if(type==""):
            print("对不起请输入要抽取转换的类型...")

    # 词性识别
    def posseg(self,str):
        words = posseg.cut(str)
        for w in words:
            print(w.word,w.flag)

if __name__ == "__main__":
    dictPath ="jibea_dic.txt"
    str = "线程是程序执行时的最小单位，它是进程的一个执行流，\
        是CPU调度和分派的基本单位，一个进程可以由很多个线程组成，\
        线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。\
        线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。\
        同样多线程也可以实现并发操作，每个请求分配一个线程来处理。"
    jf = JibeaFunciont(dictPath)
    #jf.cutWord(str)
    jf.loadDict("周围神经浸润、肠道梗阻或穿孔",dictPath)
    #jf.extractWord_TFIDF(str)
    #jf.extractKeyWord(str,"tfidf")
    #jf.extractKeyWord(str,"textrank")
    #jf.posseg(str)

其他框架也可以按照这个来进行学习和掌握.ok 在掌握了这些基础框架之后,就可以做很多其他的功能,这个放在后面再说,关于分词和分词框架的使用就介绍到额,和分词相关的常用算法,放在下一个章节来介绍.

如果自己像深入掌握分词框架,建议可以选择其中一种功能丰富的框架进行源码级别的分析,个人建议可以选择hanlp