决策树算法（非常详细，Python实现）

应用最广的归纳推理算法之一是决策树（decision tree）学习，它是一种逼近离散值函数的方法。在这种方法中学习到的函数被表示为一棵决策树，学习得到的决策树也能再被表示为多个 if-then 规则，以提高可读性。

决策树学习算法有很多，如 ID3、C4.5、ASSISTANT 等。决策树学习方法为：搜索一个完整表示的假设空间，从而避免受限假设空间的不足。决策树学习的归纳偏置是优先选择较小的树。

何为决策树

决策树就是一棵树，一棵决策树包含一个根节点、若干内部节点和若干叶节点；叶节点对应于决策结果，其他每个节点则对应于一个属性测试；每个节点包含的样本集合根据属性测试的结果被划分到子节点中；根节点包含样本全集，从根节点到每个叶子节点的路径对应了一个判定测试序列。

【实例】在一个水果的分类问题中，采用特征向量为（颜色，尺寸，形状，味道），其中：

• 颜色属性的取值范围：红、绿、黄；
• 尺寸属性的取值范围：大、中、小；
• 形状属性的取值范围：圆、细；
• 味道属性的取值范围：甜、酸；
• 样本集：一批水果，知道其特征向量及类别；

问题：一个新的水果，观测到了其特征向量，应该将其分为哪一类？

整个决策树效果如下图所示：


通常决策树代表实例属性值约束的合取（conjunction）的析取式（disjunction）。从树根到树叶的每一条路径都对应一组属性测试的合取，树本身对应这些合取的析取。

上述例子可对应如下析取式：

（颜色=绿∧尺寸=大）
∨（颜色=绿∧尺寸=中）
∨（颜色=绿∧尺寸=小）
∨（颜色=黄∧形状=圆∧尺寸=大）
∨（颜色=黄∧形状=圆∧尺寸=小）
∨（颜色=黄∧形状=细）
∨（颜色=红∧尺寸=中）
∨（颜色=红∧尺寸=小∧味道=甜）
∨（颜色=红∧尺寸=小∧味道=酸）

实际上，构造一棵决策树要解决的如下 4 个问题：

• 收集待分类的数据，这些数据的所有属性应该是完全标注的；
• 设计分类原则，即数据的哪些属性可以被用来分类，以及如何将该属性量化；
• 分类原则的选择，即在众多分类准则中，每一步选择哪一准则使最终的树更令人满意；
• 设计分类停止条件：
  • 该节点包含的数据太少不足以分裂；
  • 继续分裂数据集对树生成的目标没有贡献；
  • 树的深度过大不宜再分。

决策树生成

1) 信息增益

决策树学习的关键在于如何选择最优的划分属性。

所谓最优划分属性，对于二元分类而言，就是尽量使划分的样本属于同一类别，即“纯度”最高的属性。那么如何来度量特征的纯度，这时候就要用到“信息熵”。

先来看看信息熵的定义：假如当前样本集D中第k类样本所占的比例为 pk(k=1, 2, …, |y|)，|y| 为类别的总数（对于二元分类来说，|y|=2）。则样本集的信息熵为：


其中，Ent(D) 的值越小，则 D 的纯度越高。

假定离散属性 a 有 V 个可能的取值 {a1，a2，…，aV}，如果使用特征 a 对数据集 D 进行划分，则会产生 V 个分支节点，其中第 v（v=1，2，…，V）个节点包含了数据集 D 中所有在特征 a 上取值为 av（v=1，2，…，V）的样本总数，记为 Dv。因此，可以根据上面信息熵的公式计算出信息熵。再考虑不同的分支节点所包含的样本数量不同，给分支节点赋予权重：


从这个公式能够发现包含的样本数越多的分支节点的影响越大（这是信息增益的一个缺点，即信息增益对可取值数目多的特征有偏好，即该属性能取的值越多，信息增益越偏向这个）。因此，能够计算出特征对样本集 D 进行划分所获得的“信息增益”：


一般而言，信息增益越大，表示使用特征对数据集划分所获得的“纯度提升”越大。所以信息增益可以用于决策树划分属性的选择，其实就是选择信息增益最大的属性。

2) 信息增益率

信息增益率的定义为：


其中：


IV(a) 称为属性 a 的“固有值”，属性 a 的可能取值数目越多（即 V 越大），则 IV(a) 的值通常会越大。但增益率也可能产生一个问题就是，对可取数值数目较少的属性有所偏好，因此算法并不是直接选择使用增益率最大的候选划分属性，而是使用了一个启发式算法：先从候选划分属性中找出信息增益高于平均水平的属性，再从中选择信息增益率最高的。

3) 基尼指数

基尼指数（Gini index）也可以用于选择划分特征，如CART（Classification And Regression Tree，分类和回归树，分类和回归都可以用）就是使用基尼指数来选择划分特征。基尼值可表示为：


Gini(D) 反映了从数据集 D 中随机抽取两个样本，其类别标记不一致的概率，因此，Gini(D) 越小，则数据集 D 的纯度越高。则属性 a 的基尼指数定义为：


所以在候选属性集中，选择使得划分后基尼指数最小的属性作为最优划分属性。

决策树的剪枝

剪枝作为决策树后期处理的重要步骤，是必不可少的。没有剪枝，就是一个完全生长的决策树，是过拟合的，通常需要去掉一些不必要的节点以使得决策树模型更具有泛化能力。

决策树的剪枝方法主要有两种，分别为预剪枝和后剪枝。

1) 预剪枝（pre-pruning）

预剪枝是在构造决策树的同时进行剪枝。所有决策树的构建方法，都是在无法进一步降低熵的情况下才会停止创建分支的过程，为了避免过拟合，可以设定一个阈值，熵减小的数量小于这个阈值，即使还可以继续降低熵，也停止继续创建分支。

但是这种方法实际中的效果并不好，因为在实际中，面对不同问题，很难有一个明确的阈值可以保证树模型足够好。

2) 后剪枝（post-pruning）

后剪枝的剪枝过程是删除一些子树，然后用其叶节点代替。这个叶节点所标识的类别用这棵子树中大多数训练样本所属的类别来标识。

决策树构造完成后进行剪枝。剪枝的过程是对拥有同样父节点的一组节点进行检查，判断如果将其合并，熵的增加量是否小于某一阈值。如果确实小，则这一组节点可以合并为一个节点，其中包含了所有可能的结果。后剪枝是目前最普遍的做法。

使用sklearn预测个人情况

构建决策树的算法有很多，本节实例只使用 ID3 算法构建决策树。

ID3 算法的核心是在决策树各个节点上对应信息增益准则选择特征，递归地构建决策树。具体方法：

• 从根节点开始，对节点计算所有可能的特征的信息增益，选择信息增益最大的特征作为节点的特征，由该特征的不同取值建立子节点；
• 再对子节点递归地调用以上方法，构建决策树；
• 直到所有特征的信息增益均很小或没有特征可以选择为止，最后得到一棵决策树。

ID3 算法相当于用极大似然法进行概率模型的选择。

在使用 ID3 算法构造决策树之前，先分析下表中的数据。


因为特征 A3（是否有自己的房子）的信息增益值最大，所以选择特征 A3 作为根节点的特征。它将训练集 D 划分为两个子集 D1（A3 取值为“是”）和 D2（A3 取值为“否”）。因为 D1 只有同一类的样本点，所以它成为一个叶节点，节点的类标记为“是”。

对 D2 则需要从特征 A1（年龄类别），A2（是否有工作）和 A4（信贷情况）中选择新的特征，计算各个特征的信息增益：

g(D2, A1)=H(D2)-H(D2|A1)=0.251
g(D2, A2)=H(D2)-H(D2|A2)=0.918
g(D2, A4)=H(D2)-H(D2|A4)=0.474

根据计算，选择信息增益最大的特征 A2（是否有工作）作为节点的特征。因为 A2 有两个可能取值，从这一节点引出两个子节点：一个对应“是”（有工作）的子节点，包含 3 个样本，它们属于同一类，所以这是一个叶节点，类标记为“是”；另一个对应“否”（无工作）的子节点，包含6个样本，它们也属于同一类，所以这也是一个叶节点，类标记为“否”。

这样就生成了一棵决策树，该决策树只用了两个特征（有两个内部节点），生成的决策树如下图所示。


这样就使用 ID3 算法构建出决策树，接下来，看看如何进行代码实现。

1) 构建决策树

创建函数 majorityCnt 统计 classList 中出现此处最多的元素（类标签），创建函数 createTree 用来递归构建决策树。编写代码如下：

#- * -coding:UTF-8- * -
from math import log
import operator

def calcShannonEnt（dataSet）:
    """
    函数说明:计算给定数据集的经验熵（香农熵）
        dataSet:数据集
        shannonEnt:经验熵（香农熵）
    """
    numEntires = len（dataSet）                          #返回数据集的行数
    labelCounts = {}                                     #保存每个标签出现次数的字典
    for featVec in dataSet:                              #对每组特征向量进行统计
        currentLabel = featVec[-1]                       #提取标签信息
        if currentLabel not in labelCounts.keys（）:     #如果标签没有放入统计次数的字典，
                                                         #则添加进去
             labelCounts[currentLabel] = 0
        labelCounts[currentLabel] += 1                   #标签计数
    shannonEnt = 0.0                                     #经验熵（香农熵）
    for key in labelCounts:                              #计算香农熵
        prob = float（labelCounts[key]）/numEntires      #选择该标签的概率
        shannonEnt -= prob * log（prob，2）              #利用公式计算
    return shannonEnt                                    #返回经验熵（香农熵）

def createDataSet（）:
    """
    函数说明:创建测试数据集
        dataSet:数据集
        labels:特征标签
    """
    dataSet = [[0，0，0，0，'no']，                      #数据集
              [0，0，0，1，'no']，
              [0，1，0，1，'yes']，
              [0，1，1，0，'yes']，
              [0，0，0，0，'no']，
              [1，0，0，0，'no']，
              [1，0，0，1，'no']，
              [1，1，1，1，'yes']，
              [1，0，1，2，'yes']，
              [1，0，1，2，'yes']，
              [2，0，1，2，'yes']，
              [2，0，1，1，'yes']，
              [2，1，0，1，'yes']，
              [2，1，0，2，'yes']，
              [2，0，0，0，'no']]
    labels = ['年龄类别'，'是否有工作'，'是否有自己的房子'，'信贷情况']　　　#特征标签
    return dataSet，labels                                #返回数据集和分类属性

def splitDataSet（dataSet，axis，value）:
    """
    函数说明:按照给定特征划分数据集
    dataSet:待划分的数据集
      axis:划分数据集的特征
      value:需要返回的特征的值
    """
    retDataSet = []                                       #创建返回的数据集列表
    for featVec in dataSet:                               #遍历数据集
        if featVec[axis] == value:
             reducedFeatVec = featVec[:axis]              #去掉axis特征
             reducedFeatVec.extend（featVec[axis+1:]）    #将符合条件的添加到返回的数据集
             retDataSet.append（reducedFeatVec）
    return retDataSet                                     #返回划分后的数据集

def chooseBestFeatureToSplit（dataSet）:
    """
    函数说明:选择最优特征
        dataSet:数据集
      bestFeature:信息增益最大的（最优）特征的索引值
    """
    numFeatures = len（dataSet[0]）-1                     #特征数量
    baseEntropy = calcShannonEnt（dataSet）               #计算数据集的香农熵
    bestInfoGain = 0.0                                    #信息增益
    bestFeature = -1                                      #最优特征的索引值
    for i in range（numFeatures）:                        #遍历所有特征
        #获取dataSet的第i个特征
        featList=[example[i]for example in dataSet]
        uniqueVals=set（featList）                        #创建set集合{}，元素不可重复
        newEntropy=0.0                                    #经验条件熵
        for value in uniqueVals:                             #计算信息增益
             subDataSet=splitDataSet（dataSet，i，value）　　#subDataSet划分后的子集
             prob=len（subDataSet）/float（len（dataSet））  #计算子集的概率
             newEntropy+=prob * calcShannonEnt（subDataSet） #根据公式计算经验条件熵
        infoGain=baseEntropy-newEntropy                      #信息增益
             if（infoGain＞bestInfoGain）:                   #计算信息增益
             bestInfoGain=   infoGain              #更新信息增益，找到最大的信息增益
             bestFeature=   i                      #记录信息增益最大的特征的索引值
    return bestFeature                             #返回信息增益最大的特征的索引值

def majorityCnt（classList）:
    """
    函数说明:统计classList中出现最多的元素（类标签）
        classList:类标签列表
      sortedClassCount[0][0]:出现最多的元素（类标签）
    """
    classCount = {}
    for vote in classList:                         #统计classList中每个元素出现的次数
        if vote not in classCount.keys（）:classCount[vote] = 0
        classCount[vote] += 1
    sortedClassCount = sorted（classCount.items（），key = operator.itemgetter（1），reverse = True）
                                                   #根据字典的值降序排序
    return sortedClassCount[0][0]                  #返回classList中出现次数最多的元素

def createTree（dataSet，labels，featLabels）:
    """
    函数说明:创建决策树
      dataSet:训练数据集
       labels:分类属性标签
       featLabels:存储选择的最优特征标签
       myTree:决策树
    """
    classList = [example[-1]for example in dataSet]       　#取分类标签（是否有贷款:yes or no）
    if classList.count（classList[0]） == len（classList）: #如果类别完全相同则停止继续划分
        return classList[0]
    if len（dataSet[0]） == 1 or len（labels） == 0:        #遍历完所有特征时返回出现次数最多
                                                            #的类标签
        return majorityCnt（classList）
    bestFeat = chooseBestFeatureToSplit（dataSet）          #选择最优特征
    bestFeatLabel = labels[bestFeat]                        #最优特征的标签
    featLabels.append（bestFeatLabel）
    myTree = {bestFeatLabel:{}}                             #根据最优特征的标签生成树
    del（labels[bestFeat]）                                 #删除已经使用的特征标签
    featValues = [example[bestFeat]for example in dataSet]　　      #得到训练集中所有最优特征的
                                                                    #属性值
    uniqueVals = set（featValues）                          #去掉重复的属性值
    for value in uniqueVals:                                #遍历特征，创建决策树
        subLabels = labels[:]
         myTree[bestFeatLabel][value] = createTree（splitDataSet（dataSet，bestFeat，value），
subLabels，featLabels）
    return myTree

if__name__ == '__main__':
    dataSet，labels = createDataSet（）
    featLabels = []
    myTree = createTree（dataSet，labels，featLabels）
    print（myTree）

运行程序，输出如下：

{'是否有自己的房子':{0:{'是否有工作':{0:'no'，1:'yes'}}，1:'yes'}}

递归创建决策树时，递归有两个终止条件：

• 第一个停止条件是所有的类标签完全相同，则直接返回该类标签；
• 第二个停止条件是使用完了所有特征，仍然不能将数据划分仅包含唯一类别的分组，即决策树构建失败，特征不够用。

此时说明数据维度不够，由于第二个停止条件无法简单地返回唯一的类标签，这里挑选出现数量最多的类别作为返回值。

由结果可见，决策树已经构建完成了。为了使结果更直观，可以使用强大的Matplotlib绘制决策树。

2) 决策树可视化

在实现可视化代码中，需要用到的 Matplotlib 可视化函数有：

• getNumLeafs：获取决策树叶节点的数目；
• getTreeDepth：获取决策树的层数；
• plotNode：绘制节点；
• plotMidText：标注有向边属性值；
• plotTree：绘制决策树；
• createPlot：创建绘制面板。

代码编写如下：

#- * -coding:UTF-8- * -
from matplotlib.font_manager import FontProperties
import matplotlib.pyplot as plt
from math import log
import operator

...#此处省略与上面相同的代码
def getNumLeafs（myTree）:
    """
    函数说明:获取决策树叶节点的数目
        myTree:决策树
        numLeafs:决策树的叶节点的数目
    """
    numLeafs=0                                            #初始化叶节点
    firstStr=next（iter（myTree））　　　#Python 3中myTree.keys返回的是dict_keys，不是list
          #所以不能使用myTree.keys（）[0]的方法获取节点属性，可以使用list（myTree.keys（））[0]
    secondDict=myTree[firstStr]                           #获取下一组字典
    for key in secondDict.keys（）:
        if type（secondDict[key]）.__name__=='dict':      #测试该节点是否为字典，如果不是字典
                                                          #则代表此节点为叶节点
             numLeafs+=getNumLeafs（secondDict[key]）
        else:numLeafs+=1
    return numLeafs

def getTreeDepth（myTree）:
    """
    函数说明:获取决策树的层数
        myTree:决策树
        maxDepth:决策树的层数
    """
    maxDepth=0                                            #初始化决策树深度
    firstStr=next（iter（myTree））　　　#Python 3中myTree.keys返回的是dict_keys，不是list
             #所以不能使用myTree.keys（）[0]方法获取节点属性，可以使用list（myTree.keys（））[0]
    secondDict=myTree[firstStr]                           #获取下一个字典
    for key in secondDict.keys（）:
        if type（secondDict[key]）.__name__=='dict':      #测试该节点是否为字典，如果不是字典，
                                                          #则代表此节点为叶节点
             thisDepth=   1+getTreeDepth（secondDict[key]）
        else:thisDepth=1
        if thisDepth＞maxDepth:maxDepth=thisDepth         #更新层数
    return maxDepth

def plotNode（nodeTxt，centerPt，parentPt，nodeType）:
    """
    函数说明:绘制节点
        nodeTxt:节点名
        centerPt:文本位置
        parentPt:标注的箭头位置
        nodeType:节点格式
    """
    arrow_args=dict（arrowstyle="＜-"）                   #定义箭头格式
    font=FontProperties（fname=r"c:\windows\fonts\simsun.ttc"，size=14）　   　　#设置中文字体
    createPlot.ax1.annotate（nodeTxt，xy=parentPt，xycoords='axes fraction'，　　#绘制节点
        xytext=centerPt，textcoords='axes fraction'，
        va="center"，ha="center"，bbox=nodeType，arrowprops=arrow_args，FontProperties=font）

def plotMidText（cntrPt，parentPt，txtString）:
   """
   函数说明:标注有向边属性值
       cntrPt、parentPt:用于计算标注位置
       txtString:标注的内容
   """
   xMid=（parentPt[0]-cntrPt[0]）/2.0+cntrPt[0]
    #计算标注位置
   yMid=（parentPt[1]-cntrPt[1]）/2.0+cntrPt[1]
   createPlot.ax1.text（x M id，y M id，txtString，va="center"，ha="center"，rotation=30）

def plotTree（myTree，parentPt，nodeTxt）:
   """
    函数说明:绘制决策树
        myTree:决策树（字典）
        parentPt:标注的内容
        nodeTxt:节点名
    """
        decisionNode=dict（boxstyle="sawtooth"，fc="0.8"）       　#设置节点格式
    leafNode=dict（boxstyle="round4"，fc="0.8"）                   #设置叶节点格式
    numLeafs=getNumLeafs（myTree）　　　#获取决策树叶节点数目，决定了树的宽度
    depth=getTreeDepth（myTree）                                   #获取决策树层数
    firstStr=next（iter（myTree））                                #下一个字典
    cntrPt=（plotTree.xOff+（1.0+float（numLeafs））/2.0/plotTree.totalW，plotTree.yOff）
                                                                   #中心位置
    plotMidText（cntrPt，parentPt，nodeTxt）                       #标注有向边属性值
    plotNode（firstStr，cntrPt，parentPt，decisionNode）           #绘制节点
    secondDict=myTree[firstStr]　　　#下一个字典，也就是继续绘制子树
    plotTree.yOff=plotTree.yOff-1.0/plotTree.totalD                #y偏移
    for key in secondDict.keys（）:
         if type（secondDict[key]）.__name__=='dict':
    #测试该节点是否为字典，如果不是字典，则代表此节点为叶节点
             plotTree（secondDict[key]，cntrPt，str（key））
             #不是叶节点，递归调用继续绘制
             else:
             #如果是叶节点，则绘制叶节点，并标注有向边属性值
                 plotTree.xOff=plotTree.xOff+1.0/plotTree.totalW
                 plotNode（secondDict[key]，（plotTree.xOff，plotTree.yOff），cntrPt，leafNode）
                 plotMidText（（plotTree.xOff，plotTree.yOff），cntrPt，str（key））
    plotTree.yOff=plotTree.yOff+1.0/plotTree.totalD

def createPlot（inTree）:
    """
    函数说明:创建绘制面板
         inTree:决策树（字典）
    """
    fig=plt.figure（1，facecolor='white'）
#创建图形
    fig.clf（）
#清空图形
    axprops=dict（xticks=[]，yticks=[]）
    createPlot.ax1=plt.subplot（111，frameon=False， * * axprops）
#去掉x、y轴
    plotTree.totalW=float（getNumLeafs（inTree））
#获取决策树叶节点数目
    plotTree.totalD=float（getTreeDepth（inTree））
#获取决策树层数
    plotTree.xOff=-0.5/plotTree.totalW;plotTree.yOff=1.0;
#x偏移
    plotTree（inTree，（0.5，1.0），''）
#绘制决策树
    plt.show（）
#显示绘制结果

if__name__==    '__main__':
    dataSet，labels=createDataSet（）
    featLabels=[]
    myTree=createTree（dataSet，labels，featLabels）
    print（myTree）
    createPlot（myTree）

运行程序，输出如下：

{'是否有自己的房子':{0:{'是否有工作':{0:'no'，1:'yes'}}，1:'yes'}}

得到决策树效果如图所示：


代码中，plotNode 函数的工作就是绘制各个节点，如是否有自己的房子、是否有工作、yes、no，包括内节点和叶节点。plotMidText 函数的工作就是绘制各个有向边的属性，如各个有向边的 0 和 1。

3) 使用决策树执行分类

依靠训练数据构造了决策树之后，可以将它用于实际数据的分类：

• 首先，在执行数据分类时，需要决策树及用于构造树的标签向量；
• 然后，比较测试数据与决策树上的数值，递归执行该过程直到进入叶节点；
• 最后，将测试数据定义为叶节点所属的类型。

在构建决策树的代码中，可以看到，有一个 featLabels 参数，它是用来记录各个分类节点的，在用决策树做预测时，按顺序输入需要的分类节点的属性值即可。

用决策树做分类的代码很简单，具体代码如下：

#- * -coding:UTF-8- * -
from math import log
import operator
...#此处省略与上面相同的代码

def classify（inputTree，featLabels，testVec）:
    """
    函数说明:使用决策树分类
        inputTree:已经生成的决策树
        featLabels:存储选择的最优特征标签
        testVec:测试数据列表，顺序对应最优特征标签
        classLabel:分类结果
    """
    firstStr=next（iter（inputTree））
    #获取决策树节点
    secondDict=   inputTree[firstStr]
    #下一个字典
    featIndex=featLabels.index（firstStr）
    for key in secondDict.keys（）:
        if testVec[featIndex]==key:
             if type（secondDict[key]）.__name__==   'dict':
                 classLabel=classify（secondDict[key]，featLabels，testVec）
             else:classLabel=secondDict[key]
    return classLabel

if__name__==    '__main__':
    dataSet，labels=createDataSet（）
    featLabels=[]
    myTree=createTree（dataSet，labels，featLabels）
    testVec=[0，1]　　　　　#测试数据
    result=classify（myTree，featLabels，testVec）
    if result==   'yes':
        print（'放贷'）
    if result==   'no':
        print（'不放贷'）

这里只增加了 classify 函数，用于决策树分类。输入测试数据 [0，1] ，它代表没有房子，但是有工作，分类结果如下所示：

放贷

那是不是每次做预测都要训练一次决策树呢？并不是这样的，可通过决策树的存储方法解决此问题。

4) 决策树的存储

即使处理很小的数据集，构造决策树也是很耗时的，如前面的样本数据，也要花费几秒的时间，如果数据集很大，耗费的计算时间将会很长。然而，用创建好的决策树解决分类问题，则可以很快完成。因此，为了节省计算时间，最好在每次执行分类时调用已经构造好的决策树。

为了解决这个问题，需要使用 Python 模块 pickle 序列化对象。序列化对象后即可在磁盘上保存对象，并在需要时将其读取出来。

假设已经得到决策树{'是否有自己的房子'：{0：{'是否有工作'：{0：'no'，1：'yes'}}，1：'yes'}}，使用 pickle.dump 存储决策树：

#- * -coding:UTF-8- * -
import pickle

def storeTree(inputTree, filename):
    """
    函数说明:存储决策树
         inputTree:已经生成的决策树
        filename:决策树的存储文件名
    """
    with open(filename, 'wb') as fw:
        pickle.dump(inputTree, fw)

if__name__==    '__main__':
    myTree={'是否有自己的房子':{0:{'是否有工作':{0:'no'，1:'yes'}}，1:'yes'}}
    storeTree(myTree, 'classifierStorage.txt')

运行代码，在该 Python 文件的相同目录下，会生成一个名为 classifierStorage.txt 的文本文件，这个文件二进制存储着决策树，可以使用 Sublime Text 将文件打开查看存储结果，如下图所示：


图 12 所示的内容是一个二进制存储的文件，我们不需要看懂里面的内容，会存储、会用即可。

如果下次需要使用这个存储完的二进制文件，使用 pickle.load 进行载入即可。编写代码如下：

#- * -coding:UTF-8- * -
import pickle
　　　　　　　　　　
def grabTree(filename):
    """
    函数说明:读取决策树
        filename:决策树的存储文件名
        pickle.load（fr）:决策树字典
    """
    fr=open(filename, 'rb')
    return pickle.load(fr)
　　　　　　　　　　
if__name__==    '__main__':
    myTree=grabTree('classifierStorage.txt')
    print(myTree)

运行程序，输出如下：

{'是否有自己的房子':{0:{'是否有工作':{0:'no'，1:'yes'}}，1:'yes'}}

从上述结果中可以看到，已顺利加载了存储决策树的二进制文件。