对于西方拼音语言来说，从词之间由明确的分界符，而很多亚洲语言（如汉语、日语、韩语、泰语）词之间没有明确的分界符，因此需要先对句子进行分词，才能做进一步的自然语言处理（也适用于英文词组的分割、或者手写识别，平板电脑、智能手机手写时单词间的空格可能不清楚）。

分词的输入是一串词，分词的输出是用分界符分割的一串词。

分词的不一致性问题：


越界型错误：“北京大学生” -> “北京大学”、“生”
覆盖型错误：“北京大学” -> “北”、“京”、“大”、“学”
颗粒度的不一致性


分词的颗粒问题：


在分词的同时，找到复合词的嵌套结构。如“北京”、“大学”、“北京大学”
机器翻译：一般来讲，颗粒度大翻译效果好。如“北京大学”
语音识别，网页搜索：一般来讲，颗粒度小效果好。如“北京”、“大学”


中文分词是一个已解决问题，只要采用统计语言模型，效果差不到哪去。一般不同应用该有不同的分词系统，需要针对不同的应用设计实现专门的分词系统。 构造分词器时，更好的做法是让一个分词器同时支持不同层次的词的切分，由不同的应用自行决定切分的颗粒度。通常中文分词工作的重点是继续做数据挖掘，不断完善复合词的词典（新词发现）。



基于字符串匹配的分词方法（“查字典”）

此方法按照不同的扫描方式，逐个查找词库进行分词。根据扫描方式可细分为：正向最大匹配，反向最大匹配，双向最大匹配，最小切分(即最短路径)；总之就是各种不同的启发规则。



全切分方法

它首先切分出与词库匹配的所有可能的词，再运用统计语言模型决定最优的切分结果。最好的一种分词方法应该保证分完词后这个句子出现的概率最大。

问题：穷举所有可能的分词方法并计算每种可能性的句子的概率，计算量相当大。

技巧：看成一个动态规划（Dynamic Programming）问题，利用维特比（Viterbi）算法快速地找到最佳分词。



维特比（Viterbi）算法

维特比算法是一个特殊但是应用最广的动态规划算法。利用动态规划，可以解决任何一个图中的最短路径问题。维特比算法是针对一个特殊的图—— 篱笆网络（Lattice） 的有向图最短路径问题而提出的。凡是使用隐含马尔可夫模型描述的问题都要用它来解码，如语音识别、机器翻译、拼音转汉字（中文输入法）、分词。

例如输入法，输入的可见序列为 $y_1, y_2,...,y_N$，而产生它们的隐含序列是 $x_1, x_2,...,x_N$





 $$x_1, x_2,...,x_N = argmax_{x \in X} P(x_1, x_2,...,x_N | y_1, y_2,...,y_N)$$ 




 $$\qquad \qquad  = argmax_{x \in X} \prod_{i=1}^N P(y_i|x_i) \cdot P(x_i|x_{i-1})$$ 


$P(x_i|x_{i-1})$ 是状态之间的转移概率，$P(y_i|x_i)$ 是每个状态的产生概率。



维特比算法:


从点 $S$ 开始，对于第一个状态 $x_1$ 的各个节点，计算距离  

$d(S,x_i)$ ，只有一步所以都是最短距离。
对于第二个状态 $x_2$ 的所有节点，计算 $S$ 到它们的最短距离，计算复杂度 $O(n_1 \cdot n_2)$


 $$d(S, x_{2i}) = min_{j=1}^{n_1} d(S,x_{1j}) + d(x_{1j},x_{2i})$$ 



如上从第二个状态走到第三个状态，直到最后，就得到了网络的最短路径。每一步计算的复杂度都与相邻两个状态 $S_i$ 和 $S_{i+1}$ 各自的节点数目 $n_i, n_{i+1}$的乘积成正比，假定节点最多的状态由$D$个节点，长度为$N$，算法复杂度为 $O(N \cdot D^2)$


由字构词的分词方法

可以理解为字的分类问题，也就是自然语言处理中的sequence labeling问题，通常做法里利用HMM，MAXENT，MEMM，CRF等预测文本串每个字的tag，比如B，E，I，S，这四个tag分别表示：beginning, inside, ending, single，也就是一个词的开始，中间，结束，以及单个字的词。 





一般而言，方法一和方法二在工业界用得比较多，方法三因为采用复杂的模型，虽准确率相对高，但耗时较大.

一个文本串除了分词，还需要做词性标注，命名实体识别，新词发现等。




  
《数学之美》 4 26
  
  
http://www.flickering.cn/ads/2015/02/%E8%AF%AD%E4%B9%89%E5%88%86%E6%9E%90%E7%9A%84%E4%B8%80%E4%BA%9B%E6%96%B9%E6%B3%95%E4%B8%80/

文章目录
整体介绍
三种分词模式与一个参数
关键词提取
中文歧义测试与去除停用词
三种可以让分词更准确的方法
并行计算

整体介绍
jieba 基于Python的中文分词工具,安装使用非常方便,直接pip即可,2/3都可以,功能强悍,博主十分推荐

github:https://github.com/fxsjy/jieba

开源中国地址:http://www.oschina.net/p/jieba/?fromerr=LRXZzk9z

写这篇文章花费两个小时小时,阅读需要十五分钟,读完本篇文章后您将能上手jieba
下篇博文将介绍将任意中文文本生成中文词云
同时如果你希望使用其它分词工具,那么你可以留意我之后的博客,我会在接下来的日子里发布其他有关内容.
三种分词模式与一个参数
以下代码主要来自于jieba的github,你可以在github下载该源码
import jieba

seg_list = jieba.cut("我来到北京清华大学", cut_all=True, HMM=False)
print("Full Mode: " + "/ ".join(seg_list))  # 全模式

seg_list = jieba.cut("我来到北京清华大学", cut_all=False, HMM=True)
print("Default Mode: " + "/ ".join(seg_list))  # 默认模式

seg_list = jieba.cut("他来到了网易杭研大厦", HMM=False)
print(", ".join(seg_list))

seg_list = jieba.cut_for_search("小明硕士毕业于中国科学院计算所，后在日本京都大学深造", HMM=False)  # 搜索引擎模式
print(", ".join(seg_list))

# jieba.cut的默认参数只有三个,jieba源码如下
# cut(self, sentence, cut_all=False, HMM=True)
# 分别为:输入文本 是否为全模式分词 与是否开启HMM进行中文分词


关键词提取
from os import path
import jieba.analyse as analyse

d = path.dirname(__file__)

text_path = 'txt/lz.txt' #设置要分析的文本路径
text = open(path.join(d, text_path)).read()

for key in analyse.extract_tags(text,50, withWeight=False):
# 使用jieba.analyse.extract_tags()参数提取关键字,默认参数为50
    print key.encode('utf-8')
    # 设置输出编码为utf-8不然在因为win下控制台默认中文字符集为gbk,所以会出现乱码
    # 当withWeight=True时,将会返回number类型的一个权重值(TF-IDF)


运行结果如图所示,但是同样的我们也发现了一些问题,比如:

问题一:

分词错误,在运行结果中中"路明非"(龙族男主)被分成了"路明"和"明非"啷个中文词语,这是因为jieba的词库中并不含有该词的原因,同样的原因以及jieba词库比较老,因而在许多文本分词时都会产生这种情况,而这个问题我们将在第五个模块"三种可以让分词更准确的方法"解决

问题二:

出现非实意词语,无论在哪种语言中,都会存在大量的非实意单词,这一类词云我们需要在进行中文分词时进行去除停用词,这个问题将在下一个模块中解决
中文歧义测试与去除停用词
本段代码主要来自于《机器学习实践指南（第二版））》，其作者为麦好，ps：这是一本好书
找停用词点这里：多版本中文停用词词表 + 多版本英文停用词词表 + python词表合并程序
import jieba
TestStr = "2010年底部队友谊篮球赛结束"
# 因为在汉语中没有空格进行词语的分隔，所以经常会出现中文歧义，比如年底-底部-部队-队友
# jieba 默认启用了HMM（隐马尔科夫模型）进行中文分词，实际效果不错

seg_list = jieba.cut(TestStr, cut_all=True)
print "Full Mode:", "/ ".join(seg_list) # 全模式

seg_list = jieba.cut(TestStr, cut_all=False)
print "Default Mode:", "/ ".join(seg_list) # 默认模式
# 在默认模式下有对中文歧义有较好的分类方式

seg_list = jieba.cut_for_search(TestStr) # 搜索引擎模式
print "cut for Search","/".join(seg_list)


去除文本中的停用词
# - * - coding: utf - 8 -*-
#
# 作者：田丰(FontTian)
# 创建时间:'2017/5/27'
# 邮箱：fonttian@163.com
# CSDN：http://blog.csdn.net/fontthrone

import sys
import jieba
from os import path

d = path.dirname(__file__)
stopwords_path = 'stopwords\stopwords1893.txt' # 停用词词表

text_path = 'txt/lz.txt' #设置要分析的文本路径
text = open(path.join(d, text_path)).read()

def jiebaclearText(text):
    mywordlist = []
    seg_list = jieba.cut(text, cut_all=False)
    liststr="/ ".join(seg_list)
    f_stop = open(stopwords_path)
    try:
        f_stop_text = f_stop.read( )
        f_stop_text=unicode(f_stop_text,'utf-8')
    finally:
        f_stop.close( )
    f_stop_seg_list=f_stop_text.split('\n')
    for myword in liststr.split('/'):
        if not(myword.strip() in f_stop_seg_list) and len(myword.strip())>1:
            mywordlist.append(myword)
    return ''.join(mywordlist)

text1 = jiebaclearText(text)
print text1


三种可以让分词更准确的方法
方案一，在jieba中添加中文词语：

这种方法可以有效的解决之前龙族男主"路明非"被分为"路明"和"明非"两个词的情况
#这个只需要在源代码中加入一个语句即可
import sys
import jieba
from os import path

d = path.dirname(__file__)
stopwords_path = 'stopwords\stopwords1893.txt' # 停用词词表

jieba.add_word('路明非')
# 添加的自定义中文语句的代码在这里
# 添加的自定义中文语句的代码在这里
# 添加的自定义中文语句的代码在这里

text_path = 'txt/lz.txt' #设置要分析的文本路径
text = open(path.join(d, text_path)).read()

def jiebaclearText(text):
    mywordlist = []
    seg_list = jieba.cut(text, cut_all=False)
    liststr="/ ".join(seg_list)
    f_stop = open(stopwords_path)
    try:
        f_stop_text = f_stop.read( )
        f_stop_text=unicode(f_stop_text,'utf-8')
    finally:
        f_stop.close( )
    f_stop_seg_list=f_stop_text.split('\n')
    for myword in liststr.split('/'):
        if not(myword.strip() in f_stop_seg_list) and len(myword.strip())>1:
            mywordlist.append(myword)
    return ''.join(mywordlist)

text1 = jiebaclearText(text)
print text1

运行效果如下:

方案二,添加自定义词库:

下面的代码主要来自于jieba的github源码,你可以在github下载该例子
#encoding=utf-8
from __future__ import print_function, unicode_literals
import sys
sys.path.append("../")
import jieba
jieba.load_userdict("userdict.txt")
# jieba采用延迟加载，"import jieba"不会立即触发词典的加载，一旦有必要才开始加载词典构建trie。如果你想手工初始jieba，也可以手动初始化。示例如下:
# import jieba
# jieba.initialize() #手动初始化（可选）
# 在0.28之前的版本是不能指定主词典的路径的，有了延迟加载机制后，你可以改变主词典的路径:
# 注意用户词典为主词典即优先考虑的词典,原词典此时变为非主词典
# jieba.set_dictionary('data/dict.txt.big')

import jieba.posseg as pseg

test_sent = (
"李小福是创新办主任也是云计算方面的专家; 什么是八一双鹿\n"
"例如我输入一个带“韩玉赏鉴”的标题，在自定义词库中也增加了此词为N类\n"
"「台中」正確應該不會被切開。mac上可分出「石墨烯」；此時又可以分出來凱特琳了。"
)
words = jieba.cut(test_sent)
print('/'.join(words))

print("="*40)

result = pseg.cut(test_sent)
# pseg.cut 切分,并显示词性
# 下面是userdict.txt的内容,如果不加入这个词库,那么在运行结果中,云计算,创新办等词都将无法识别
'''
云计算 5
李小福 2 nr
创新办 3 i
easy_install 3 eng
好用 300
韩玉赏鉴 3 nz
八一双鹿 3 nz
台中
凱特琳 nz
Edu Trust认证 2000
'''



下面这段代码主要来自于jieba的github,你可以在github下载该源码
print('='*40)
print('添加自定义词典/调整词典')
print('-'*40)

print('/'.join(jieba.cut('如果放到post中将出错。', HMM=False)))
#如果/放到/post/中将/出错/。
# 调整词典使 中将 变为中/将
print(jieba.suggest_freq(('中', '将'), True))
#494
print('/'.join(jieba.cut('如果放到post中将出错。', HMM=False)))
#如果/放到/post/中/将/出错/。
print('/'.join(jieba.cut('「台中」正确应该不会被切开', HMM=False)))
#「/台/中/」/正确/应该/不会/被/切开
print(jieba.suggest_freq('台中', True))
print(jieba.suggest_freq('台中', True))
#69
# 调整词典使 台中 不被分词为台/中
print('/'.join(jieba.cut('「台中」正确应该不会被切开', HMM=False)))
#「/台中/」/正确/应该/不会/被/切开

并行计算
下面这段代码主要来自于jieba的github,你可以在github下载该源码
原理：将目标文本按行分隔后，把各行文本分配到多个python进程并行分词，然后归并结果，从而获得分词速度的可观提升
基于python自带的multiprocessing模块，目前暂不支持windows
import sys
import time
sys.path.append("../../")
import jieba

jieba.enable_parallel() # 关闭并行分词
jieba.enable_parallel(4) # 开启并行分词模式，参数为并行进程数 

url = sys.argv[1]
content = open(url,"rb").read()
t1 = time.time()
words = "/ ".join(jieba.cut(content))

t2 = time.time()
tm_cost = t2-t1

log_f = open("1.log","wb")
log_f.write(words.encode('utf-8'))

print('speed %s bytes/second' % (len(content)/tm_cost))

实验结果：在4核3.4GHz Linux机器上，对金庸全集进行精确分词，获得了1MB/s的速度，是单进程版的3.3倍。

数据

提取码：sodv

  隐马尔可夫模型（Hidden Markov Model，HMM）是统计模型，它用来描述一个含有隐含未知参数的马尔可夫过程。其难点是从可观察的参数中确定该过程的隐含参数。然后利用这些参数来作进一步的分析，例如模式识别。
训练集长这样：



  HMM中文分词原理： 对于一个词语，比如“我爱中国”，每个字有都对应的状态：B、M、E、S中的一个。其中B表示开始，M表示中间，E表示结尾，S表示单独一个字。因此上述四个字的隐状态为：“BMME”。

  使用hmmlearn实现中文分词，我们要解决的核心问题就是计算三大矩阵：初始概率矩阵、转移概率矩阵以及发射概率矩阵。

对于初始概率矩阵，是一个1 X 4维的矩阵，我们用pi表示。pi[0]就是初始时B的概率，后面三个依次类推。怎么算这四个值呢？我们遍历训练集中每一个句子，如果该句子第一个词语长度大于等于2，那说明该句子是以M开头的，则pi[0]++；如果句子开头只有一个字，则pi[3]++。很显然，句子开头不可能是M或者E。 遍历完之后，矩阵中每个数再除以所有数之和即可（算概率）。
对于转义概率矩阵A，是一个4 X 4维的矩阵。比如A[0, 1]表示当前状态时B而下一状态是M的概率。具体计算方法：我们遍历所有句子，对每一个句子，我们找出B后面跟着M的个数，以及B后面跟着E的个数等等。遍历完成之后同样每一行除以该行总和。
对于发射概率矩阵B是一个4 X 65536（unicode）的矩阵。比如B[3, 25000]表示的意思就是unicode编码为25000的汉字状态为B的概率。计算方式为：遍历训练集中每一个字，利用ord(x)返回编码，如果该字隐状态为B，则B[0, ord(x)]++，以此类推。最后同样每一行除以该行所有数据之和。当然，按理说也可以不用unicode编码，我刚开始是这样做的：找到所有汉字的集合（不重复），大概有25000的样子，然后从0-24999编号。但是这样做的话时间代价很大，直接计算ord(x)显然更快。

具体步骤：

数据处理。 读取txt文件，把每一个字的隐状态都表示出来：

def load_data():
     data = open('HMM/TrainData.txt', encoding='utf-8')
     file = []
     for line in data.readlines():
         file.append(line.strip().split(' '))
     max_len = 0; temp = 0
     res = []
     for i in range(len(file)):
         for j in range(len(file[i])):
             for k in range(len(file[i][j])):
                 res.append(file[i][j][k])
     real_file = []
     for i in range(len(file)):
         x = []
         for j in range(len(file[i])):
             if len(file[i][j]) == 1:
                 x.append('S')
             elif len(file[i][j]) == 2:
                 x.append('BE')
             else:
                 str = 'B'
                 for k in range(len(file[i][j])-2):
                     str += 'M'
                 str += 'E'
                 x.append(str)
         real_file.append(x)
     return file, real_file

file表示所有词语的集合，是一个二维列表，每个列表表示一句话，每句话又被分成了词语。real_file与file一一对应，只不过是编码BMES的集合。

计算三大矩阵：

def hMM():
     file, data = load_data()    #lens表示一个出现了多少个字
     # print(list_set)
     states = ['B', 'M', 'E', 'S']   #分别表示开始中间结尾以及单个字
     A = np.zeros((4, 4))
     B = np.zeros((4, 65536))   #编码表示汉字，不用顺序
     pi = np.zeros(4)     #初始状态

     for i in range(len(data)):
         if data[i][0][0] == 'B':  #开头只能是B或者S
             pi[0] += 1
         if data[i][0][0] == 'S':
             pi[3] += 1

     pi /= np.sum(pi)   #初始状态

     for i in range(len(data)):
         for j in range(len(data[i])):
             for k in range(len(data[i][j])):
                 B[states.index(data[i][j][k]), ord(file[i][j][k])] += 1   #隐状态为data[i][j][k]时对应汉字file[i][j][k]
             if len(data[i][j]) == 1 and j + 1 < len(data[i]):
                 if data[i][j+1][0] == 'B':  #S后面接B
                     A[3, 0] += 1
                 if data[i][j+1][0] == 'S':  #S后面接S
                     A[3, 3] += 1
                 continue
             A[0, 1] += data[i][j].count('BM')
             A[0, 2] += data[i][j].count('BE')
             A[1, 2] += data[i][j].count('ME')
             if j + 1 < len(data[i]) and data[i][j + 1][0] == 'B':
                 A[2, 0] += 1
             if j + 1 < len(data[i]) and data[i][j + 1][0] == 'S':
                 A[2, 3] += 1

     for i in range(4):
         if np.sum(A[i]) != 0:
             A[i] = A[i] / np.sum(A[i])

     for i in range(4):
         B[i] /= np.sum(B[i])


训练模型：

model = hmm.MultinomialHMM(n_components=len(states))
model.startprob_ = pi
model.emissionprob_ = B
model.transmat_ = A


测试。对测试集中每一句话，对其中每一个字找到它的unicode码集合，然后利用上面训练好的模型对该集合进行解码。

if __name__ == '__main__':
     print('请稍候...')
     model = hMM()
     dataset = []
     data = open('HMM/TestData.txt', 'r+')
     for line in data.readlines():
         temp = line.strip().split('\t')
         file = []
         for x in temp:
             file.append(x)
         dataset.append(file)   #处理数据
     data = np.array(dataset)
     for k in range(4):    #四句话
         print('分词前：', str(data[k]))
         datas = []
         x = str(*data[k])   #变成字符串
         for j in x:
             datas.append(ord(j))  #寻找汉字的编码，进行decode
         xd = np.asarray(datas).reshape(-1, 1)
         pre = model.predict(xd)
         final = []
         for p, q in enumerate(pre):
             if q == 0:
                 t = p
             elif q == 2:
                 final.append(x[t:p + 1])
             elif q == 3:
                 final.append(x[p])
         print("分词后:", '/'.join(final))
         print('\n')

完整代码：
from hmmlearn import hmm
import numpy as np

def load_data():
     data = open('HMM/TrainData.txt', encoding='utf-8')
     file = []
     for line in data.readlines():
         file.append(line.strip().split(' '))
     max_len = 0; temp = 0
     res = []
     for i in range(len(file)):
         for j in range(len(file[i])):
             for k in range(len(file[i][j])):
                 res.append(file[i][j][k])
     real_file = []
     for i in range(len(file)):
         x = []
         for j in range(len(file[i])):
             if len(file[i][j]) == 1:
                 x.append('S')
             elif len(file[i][j]) == 2:
                 x.append('BE')
             else:
                 str = 'B'
                 for k in range(len(file[i][j])-2):
                     str += 'M'
                 str += 'E'
                 x.append(str)
         real_file.append(x)
     return file, real_file


#训练
def hMM():
     file, data = load_data()    #lens表示一个出现了多少个字
     # print(list_set)
     states = ['B', 'M', 'E', 'S']   #分别表示开始中间结尾以及单个字
     A = np.zeros((4, 4))
     B = np.zeros((4, 65536))   #编码表示汉字，不用顺序
     pi = np.zeros(4)     #初始状态

     for i in range(len(data)):
         if data[i][0][0] == 'B':  #开头只能是B或者S
             pi[0] += 1
         if data[i][0][0] == 'S':
             pi[3] += 1

     pi /= np.sum(pi)   #初始状态

     for i in range(len(data)):
         for j in range(len(data[i])):
             for k in range(len(data[i][j])):
                 B[states.index(data[i][j][k]), ord(file[i][j][k])] += 1   #隐状态为data[i][j][k]时对应汉字file[i][j][k]
             if len(data[i][j]) == 1 and j + 1 < len(data[i]):
                 if data[i][j+1][0] == 'B':  #S后面接B
                     A[3, 0] += 1
                 if data[i][j+1][0] == 'S':  #S后面接S
                     A[3, 3] += 1
                 continue
             A[0, 1] += data[i][j].count('BM')
             A[0, 2] += data[i][j].count('BE')
             A[1, 2] += data[i][j].count('ME')
             if j + 1 < len(data[i]) and data[i][j + 1][0] == 'B':
                 A[2, 0] += 1
             if j + 1 < len(data[i]) and data[i][j + 1][0] == 'S':
                 A[2, 3] += 1

     for i in range(4):
         if np.sum(A[i]) != 0:
             A[i] = A[i] / np.sum(A[i])

     for i in range(4):
         B[i] /= np.sum(B[i])
     #训练模型
     model = hmm.MultinomialHMM(n_components=len(states))
     model.startprob_ = pi
     model.emissionprob_ = B
     model.transmat_ = A
     return model

if __name__ == '__main__':
     print('请稍候...')
     model = hMM()
     dataset = []
     data = open('HMM/TestData.txt', 'r+')
     for line in data.readlines():
         temp = line.strip().split('\t')
         file = []
         for x in temp:
             file.append(x)
         dataset.append(file)   #处理数据
     data = np.array(dataset)
     for k in range(4):    #四句话
         print('分词前：', str(data[k]))
         datas = []
         x = str(*data[k])   #变成字符串
         for j in x:
             datas.append(ord(j))  #寻找汉字的编码，进行decode
         xd = np.asarray(datas).reshape(-1, 1)
         pre = model.predict(xd)
         final = []
         for p, q in enumerate(pre):
             if q == 0:
                 t = p
             elif q == 2:
                 final.append(x[t:p + 1])
             elif q == 3:
                 final.append(x[p])
         print("分词后:", '/'.join(final))
         print('\n')


输出：
分词前： ['长春市长春节讲话。']
分词后: 长春/市长/春节/讲话/。


分词前： ['他说的确实在理.']
分词后: 他/说/的/确实/在理


分词前： ['毛主席万岁。']
分词后: 毛主席/万/岁/。


分词前： ['我有一台电脑。']
分词后: 我有/一台/电脑/。

文章目录
基于python中jieba包的中文分词中详细使用（一）
01.前言
02.jieba的介绍
02.1 What
02.2特点
02.3安装与使用
02.4涉及到的算法
03.主要功能
03.01分词
03.02添加自定义词典
03.02调整词典
04.结束语

基于python中jieba包的中文分词中详细使用（一）
01.前言
之前的文章中也是用过一些jieba分词但是基本上都是处于皮毛，现在就现有的python环境中对其官方文档做一些自己的理解以及具体的介绍。本文主要内容也是从官网文档中获取。
02.jieba的介绍
02.1 What
“jieba” （Chinese for “to stutter”）Chiese text segmention:built to be the best Python Chinse word segmenmtation module.

"jieba"中文分词：做最好的Python中文分词组件
02.2特点

支持三种分词模式：

精确模式，试图将句子最精确地切开，适合文本分析；

全模式，把句子中所有的可以成词的词语都扫描处理，速度非常快，但是不能解决歧义；

搜索引擎模式，在精确模式的基础上，对长词再次切分，提高召回率，适合用于引擎分词。
支持繁体分词
支持自定义词典
MIT授权协议

02.3安装与使用
鉴于当前提供各大包的组织逐渐放弃对Python2的维护，这里也强烈建议使用Python3。jieba分词的安装也是很简单的。

全自动安装的方式：pip install jieba (window环境)   pip3 install jieba (Linux环境)；

使用的方式：import jieba
02.4涉及到的算法

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

03.主要功能
03.01分词

jieba.cut 方法接受三个输入参数: 需要分词的字符串；cut_all 参数用来控制是否采用全模式；HMM 参数用来控制是否使用 HMM 模型
jieba.cut_for_search 方法接受两个参数：需要分词的字符串；是否使用 HMM 模型。该方法适合用于搜索引擎构建倒排索引的分词，粒度比较细
待分词的字符串可以是 unicode 或 UTF-8 字符串、GBK 字符串。注意：不建议直接输入 GBK 字符串，可能无法预料地错误解码成 UTF-8
jieba.cut 以及 jieba.cut_for_search 返回的结构都是一个可迭代的 generator，可以使用 for 循环来获得分词后得到的每一个词语(unicode)，或者用
jieba.lcut 以及 jieba.lcut_for_search 直接返回 list
jieba.Tokenizer(dictionary=DEFAULT_DICT) 新建自定义分词器，可用于同时使用不同词典。jieba.dt 为默认分词器，所有全局分词相关函数都是该分词器的映射。

代码实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Date    : 2018-05-05 22:15:13
# @Author  : JackPI (1129501586@qq.com)
# @Link    : https://blog.csdn.net/meiqi0538
# @Version : $Id$
import jieba

seg_list = jieba.cut("我来到北京清华大学", cut_all=True)
print("全模式: " + "/ ".join(seg_list))  # 全模式

seg_list = jieba.cut("我来到北京清华大学", cut_all=False)
print("精准模式: " + "/ ".join(seg_list))  # 精确模式

seg_list = jieba.cut("他来到了网易杭研大厦")  # 默认是精确模式
print(", ".join(seg_list))

seg_list = jieba.cut_for_search("小明硕士毕业于中国科学院计算所，后在日本京都大学深造")  # 搜索引擎模式
print(", ".join(seg_list))

输出结果
Building prefix dict from the default dictionary ...
Loading model from cache C:\Users\JACKPI~1\AppData\Local\Temp\jieba.cache
Loading model cost 1.026 seconds.
Prefix dict has been built succesfully.
全模式: 我/ 来到/ 北京/ 清华/ 清华大学/ 华大/ 大学
精准模式: 我/ 来到/ 北京/ 清华大学
他, 来到, 了, 网易, 杭研, 大厦
小明, 硕士, 毕业, 于, 中国, 科学, 学院, 科学院, 中国科学院, 计算, 计算所, ，, 后, 在, 日本, 京都, 大学, 日本京都大学, 深造
[Finished in 1.7s]

03.02添加自定义词典

开发者可以指定自己自定义的词典，以便包含 jieba 词库里没有的词。虽然 jieba 有新词识别能力，但是自行添加新词可以保证更高的正确率
用法： jieba.load_userdict(file_name) # file_name 为文件类对象或自定义词典的路径
词典格式和 dict.txt 一样，一个词占一行；每一行分三部分：词语、词频（可省略）、词性（可省略），用空格隔开，顺序不可颠倒。file_name 若为路径或二进制方式打开的文件，则文件必须为 UTF-8 编码。
词频省略时使用自动计算的能保证分出该词的词频

添加自定义字典举例

创新办 3 i
云计算 5
凱特琳 nz
台中


更改分词器（默认为 jieba.dt）的 tmp_dir 和 cache_file 属性，可分别指定缓存文件所在的文件夹及其文件名，用于受限的文件系统。

使用案例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Date    : 2018-05-05 22:15:13
# @Author  : JackPI (1129501586@qq.com)
# @Link    : https://blog.csdn.net/meiqi0538
# @Version : $Id$
#导入jieba包
import jieba
#管理系统路径
import sys
sys.path.append("../")
#获取自定义词典
jieba.load_userdict("userdict.txt")
#导入词性标注的包
import jieba.posseg as pseg

#添加词
jieba.add_word('石墨烯')
jieba.add_word('凱特琳')
#删除词
jieba.del_word('自定义词')
#元组类型的测试数据
test_sent = (
"李小福是创新办主任也是云计算方面的专家; 什么是八一双鹿\n"
"例如我输入一个带“韩玉赏鉴”的标题，在自定义词库中也增加了此词为N类\n"
"「台中」正確應該不會被切開。mac上可分出「石墨烯」；此時又可以分出來凱特琳了。"
)
#默认分词
words = jieba.cut(test_sent)
print('/'.join(words))#使用/把分词的结果分开

print("="*40)
#用于词性标注
result = pseg.cut(test_sent)
#使用for循环把分出的词及其词性用/隔开，并添加，和空格
for w in result:
    print(w.word, "/", w.flag, ", ", end=' ')

print("\n" + "="*40)

#对英文的分割
terms = jieba.cut('easy_install is great')
print('/'.join(terms))
#对英文和汉字的分割
terms = jieba.cut('python 的正则表达式是好用的')
print('/'.join(terms))

print("="*40)
# test frequency tune
testlist = [
('今天天气不错', ('今天', '天气')),
('如果放到post中将出错。', ('中', '将')),
('我们中出了一个叛徒', ('中', '出')),
]

for sent, seg in testlist:
    print('/'.join(jieba.cut(sent, HMM=False)))
    word = ''.join(seg)
    print('%s Before: %s, After: %s' % (word, jieba.get_FREQ(word), jieba.suggest_freq(seg, True)))
    print('/'.join(jieba.cut(sent, HMM=False)))
    print("-"*40)

结果
Building prefix dict from the default dictionary ...
Loading model from cache C:\Users\JACKPI~1\AppData\Local\Temp\jieba.cache
Loading model cost 1.063 seconds.
Prefix dict has been built succesfully.
李小福/是/创新办/主任/也/是/云计算/方面/的/专家/;/ /什么/是/八一双鹿/
/例如/我/输入/一个/带/“/韩玉赏鉴/”/的/标题/，/在/自定义/词库/中/也/增加/了/此/词为/N/类/
/「/台中/」/正確/應該/不會/被/切開/。/mac/上/可/分出/「/石墨烯/」/；/此時/又/可以/分出/來/凱特琳/了/。
========================================
李小福 / nr ,  是 / v ,  创新办 / i ,  主任 / b ,  也 / d ,  是 / v ,  云计算 / x ,  方面 / n ,  的 / uj ,  专家 / n ,  ; / x ,    / x ,  什么 / r ,  是 / v ,  八一双鹿 / nz ,  
 / x ,  例如 / v ,  我 / r ,  输入 / v ,  一个 / m ,  带 / v ,  “ / x ,  韩玉赏鉴 / nz ,  ” / x ,  的 / uj ,  标题 / n ,  ， / x ,  在 / p ,  自定义 / l ,  词库 / n ,  中 / f ,  也 / d ,  增加 / v ,  了 / ul ,  此 / r ,  词 / n ,  为 / p ,  N / eng ,  类 / q ,  
 / x ,  「 / x ,  台中 / s ,  」 / x ,  正確 / ad ,  應該 / v ,  不 / d ,  會 / v ,  被 / p ,  切開 / ad ,  。 / x ,  mac / eng ,  上 / f ,  可 / v ,  分出 / v ,  「 / x ,  石墨烯 / x ,  」 / x ,  ； / x ,  此時 / c ,  又 / d ,  可以 / c ,  分出 / v ,  來 / zg ,  凱特琳 / nz ,  了 / ul ,  。 / x ,  
========================================
easy_install/ /is/ /great
python/ /的/正则表达式/是/好用/的
========================================
今天天气/不错
今天天气 Before: 3, After: 0
今天/天气/不错
----------------------------------------
如果/放到/post/中将/出错/。
中将 Before: 763, After: 494
如果/放到/post/中/将/出错/。
----------------------------------------
我们/中/出/了/一个/叛徒
中出 Before: 3, After: 3
我们/中/出/了/一个/叛徒
----------------------------------------
[Finished in 2.6s]

03.02调整词典

使用 add_word(word, freq=None, tag=None) 和 del_word(word) 可在程序中动态修改词典。
使用 suggest_freq(segment, tune=True) 可调节单个词语的词频，使其能（或不能）被分出来。
注意：自动计算的词频在使用 HMM 新词发现功能时可能无效。

>>> print('/'.join(jieba.cut('如果放到post中将出错。', HMM=False)))
如果/放到/post/中将/出错/。
>>> jieba.suggest_freq(('中', '将'), True)
494
>>> print('/'.join(jieba.cut('如果放到post中将出错。', HMM=False)))
如果/放到/post/中/将/出错/。
>>> print('/'.join(jieba.cut('「台中」正确应该不会被切开', HMM=False)))
「/台/中/」/正确/应该/不会/被/切开
>>> jieba.suggest_freq('台中', True)
69
>>> print('/'.join(jieba.cut('「台中」正确应该不会被切开', HMM=False)))
「/台中/」/正确/应该/不会/被/切开


“通过用户自定义词典来增强歧义纠错能力” — https://github.com/fxsjy/jieba/issues/14

04.结束语
更多关于jieba分词的请关注下篇博客：基于python中jieba包的中文分词中详细使用（二）。关于更多是的自然语言处理，可以查看给人微信订阅号，里面包含大量的自然与处理、机器学习文章、学习资料等。