简述

本章构造的决策树算法能够读取数据集合，构建类似于图3-1的决策树。决策树很多任务都 是为了数据中所蕴含的知识信息，因此决策树可以使用不熟悉的数据集合，并从中提取出一系列规则，机器学习算法最终将使用这些机器从数据集中创造的规则。专家系统中经常使用决策树，而且决策树给出结果往往可以匹敌在当前领域具有几十年工作经验的人类专家。

优缺点

优点：计算复杂度不高，输出结果易于理解，对中间值的缺失不敏感，可以处理不相关特征数据。
缺点：可能会产生过度匹配问题。我们可以裁剪决策树，去掉一些不
必要的叶子节点。如果叶子节点只能增加少许信息，则可以删除该节点，将它并人到其他叶子节 点中。第9章将进一步讨论这个问题。
适用数据类型：数值型和标称型

数据集

lenses.txt 预测隐形眼镜类型

构建步骤

1.我们需要解决的第一个问题就是，当前数据集上哪个特征在划分数据分类
时起决定性作用。一 些决策树算法采用二分法划分数据，本书并不采用这种方法。如果依某个属性划分数据将会产生4个可能的值，我们数据划分成四块，并创建四个不的分支。本书将使用ID3算法划分数据集。
1.1在划分数据集之前之后信息发生的变化称为信息增益，知道如何计算信息增益，我们就可以计算每个特征值划分数据集获得的信息增益，获得信息增益最高的特征就是最好的选择。如何度量数据集的无序程度的方式是计算信息熵。
2.分类算法除了需要测量信息熵，还需要划分数据集，度量花费数据集的熵，以便判断当前是否正确地划分了数据集。我们将对每个特征划分数据集的结果计算一次信息熵，然后判断按照哪个特征划分数据集是最好的划分方式。
3.由于特征值可能多于两个，因此可能存在大于两个分支的数据集划分。第一次划分之后，数据将被向下传递到树分支的下一个节点，在这个节点上，我们可以再次划分数据。因此我们可以采用递归的原则处理数据集。 递归结束的条件是：程序遍历完所有划分数据集的属性，或者每个分支下的所有实例都具有相同的分类。
4.。如果数据集已经处理了所有属性，但是类标签依然不是唯一的，此时我们需要决定如何定义该叶子节点，在这种情况下，我们通常会采用多数表决的方法决 定该叶子节点的分类。
5,递归构建决策树
6.构造注解树
绘制一棵完整的树需要一些技巧。我们虽然有x,y坐标，但是如何放置所有的树节点却是个问 题。我们必须知道有多少个叶节点，以便可以正确确x 轴的长度；我们还需要知道树有多少层，以便可以正确确定y轴的高度
7.通 过计算树包含的所有叶子节点数，划分图形的宽度，从而计算得到当前节点中心位置，也就是 说 , 我们按照叶子节点的数目将x轴划分为若干部分。
8.依靠训练数据构造了决策树之后，我们可以将它用于实际数据的分类。在执行数据分类时，需要决策树以及用于构造树的标签向量。然后，程序比较测试数据与决策树上的数值，递归执行 该过程直到进人叶子节点；最后将测试数据定义为叶子节点所属的类型
9.为了节省计算时间，最好能够在每次执行分类时调用巳经构造好的决策树,为 了解决这个问题，需要使用python莫块pickle序列化对象.

语法

1.python语言在函数中传递的是列表的引用，在函数内部对列表对象的修改，将会影响该列表对象的整个生存周期。为了消除这个不良影响，我们需要在函数的开始声明一个新列表对象。因为该函数代码在同一数据集上被调用多次，为了不修改原始数据集，创建一个新的列表对象。
2.extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。和append()有区别：

假定存在两个列表，a和b:
>>> a= [1,2,3]
>>> b = [4 , 5 , 6]
>>> a .append(b)
>>> a
[1, 2, 3, [4, 5, 6]]
如果执行a .append(b)则列表得到了第四个元素，而且第四个元素也是一个列表。然而
如果使用extend方法：
>>> a = [ 1 , 2,3]
>>> a .extend(b)
[1, 2, 3, 4, 5, 6]
则得到一个包含a和b所有元素的列表。

3.list索引值,featVec[:a]指第0个元素到第a-1个元素，[b:]指

featVec=[1, 0, 1, 'no']
reducedFeatVec = featVec[:2]
>>>reducedFeatVec =[1, 0]
reducedFeatVec.extend(featVec[3:])
>>>reducedFeatVec =[1, 0, 'no']

4.用python语言原生的集合set数据类型。集合数据类型与列表类型似，不同之处仅在于集合类型中的每个值互不相同。从列表中创建集合是python语言得到列表中唯一元素值的最快方法
5.Python 字典(Dictionary) items() 函数以列表返回可遍历的(键, 值) 元组数组。
eg

lrt = {'a':1, 'b':2, 'c':3 }
rgj = lrt.items()
print(rgj)
>>>dict_items([('a', 1), ('b', 2), ('c', 3)])

6.operator模块提供的itemgetter函数用于获取对象的哪些维的数据，参数为一些序号（即需要获取的数据在对象中的序号）

a = [1,2,3] 
>>> b=operator.itemgetter(1)      //定义函数b，获取对象的第1个域的值
>>> b(a) 
>>> b=operator.itemgetter(1,0)  //定义函数b，获取对象的第1个域和第0个的值
>>> b(a) 
(2, 1)
要注意，operator.itemgetter函数获取的不是值，而是定义了一个函数，通过该函数作用到对象上才能获取值。

7.sorted函数
Python内置的排序函数sorted可以对list或者iterator进行排序，官网文档见：http://docs.python.org/2/library/functions.html?highlight=sorted#sorted，该函数原型为：
sorted(iterable, cmp=None, key=None, reverse=False)
参数解释：
iterable：是可迭代类型;
cmp：用于比较的函数，比较什么由key决定;
key：用列表元素的某个属性或函数进行作为关键字，有默认值，迭代集合中的一项;
reverse：排序规则. reverse = True 降序 或者 reverse = False 升序，有默认值。
返回值：是一个经过排序的可迭代类型，与iterable一样。

参数说明：
(1) cmp参数
cmp接受一个函数，拿整形举例，形式为:
def f(a,b):
return a-b
如果排序的元素是其他类型的，如果a逻辑小于b，函数返回负数；a逻辑等于b，函数返回0；a逻辑大于b，函数返回正数就行了

(2) key参数
key也是接受一个函数，不同的是，这个函数只接受一个元素,形式如下
def f(a):
return len(a)
key接受的函数返回值，表示此元素的权值，sort将按照权值大小进行排序

(3) reverse参数
接受False 或者True 表示是否逆序

例子：
(1)按照元素长度排序
L = [{1:5,3:4},{1:3,6:3},{1:1,2:4,5:6},{1:9}]
def f(x):
    return len(x)
sort(key=f) 
print L
 
输出:
[{1: 9}, {1: 5, 3: 4}, {1: 3, 6: 3}, {1: 1, 2: 4, 5: 6}]

对于本决策树中用到的sort（）
（1）iterable指定要排序的list或者iterable
（2）cmp为函数，指定排序时进行比较的函数，可以指定一个函数或者lambda函数，如：
students为类对象的list，没个成员有三个域，用sorted进行比较时可以自己定cmp函数，例如这里要通过比较第三个数据成员来排序，代码可以这样写：

      students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
      sorted(students, key=lambda student : student[2])

（3）key为函数，指定取待排序元素的哪一项进行排序，函数用上面的例子来说明，代码如下：

      sorted(students, key=lambda student : student[2])

key指定的lambda函数功能是去元素student的第三个域（即：student[2]），因此sorted排序时，会以students所有元素的第三个域来进行排序。
有了上面的operator.itemgetter函数，也可以用该函数来实现，例如要通过student的第三个域排序，可以这么写：

sorted(students, key=operator.itemgetter(2)) 

sorted函数也可以进行多级排序，例如要根据第二个域和第三个域进行排序，可以这么写：

sorted(students, key=operator.itemgetter(1,2))

即先根据第二个域排序，再根据第三个域排序。
（4）reverse参数就不用多说了，是一个bool变量，表示升序还是降序排列，默认为false（升序排列），定义为True时将按降序排列。
8.Python count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
count()方法语法：

str.count(sub, start= 0,end=len(string))
sub -- 搜索的子字符串
start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

9.python中的del用法比较特殊，新手学习往往产生误解，弄清del的用法，可以帮助深入理解python的内存方面的问题。
python的del不同于C的free和C++的delete。
由于python都是引用，而python有GC机制，所以，del语句作用在变量上，而不是数据对象上。

if __name__=='__main__':  
    a=1       # 对象 1 被 变量a引用，对象1的引用计数器为1  
    b=a       # 对象1 被变量b引用，对象1的引用计数器加1  
    c=a       #1对象1 被变量c引用，对象1的引用计数器加1  
    del a     #删除变量a，解除a对1的引用  
    del b     #删除变量b，解除b对1的引用  
    print(c)  #最终变量c仍然引用1  

del删除的是变量，而不是数据。

另外。关于list。

if __name__=='__main__':  
    li=[1,2,3,4,5]  #列表本身不包含数据1,2,3,4,5，而是包含变量：li[0] li[1] li[2] li[3] li[4]   
    first=li[0]     #拷贝列表，也不会有数据对象的复制，而是创建新的变量引用  
    del li[0]  
    print(li)      #输出[2, 3, 4, 5]  
    print(first)   #输出 1  

10." python提供了一个注解工具annotations ，非常有用，它可以在数据图形上添加文本注释。在使用annotate()时，要考虑两个点的坐标：被注释的地方xy(x, y)和插入文本的地方xytext(x, y)。
11.matplotlib.pyplot模块中的字典类型

# 定义决策树决策结果的属性，用字典来定义  
# 下面的字典定义也可写作 decisionNode={boxstyle:'sawtooth',fc:'0.8'}  
# boxstyle为文本框的类型，sawtooth是锯齿形，fc是边框线粗细  
decisionNode = dict(boxstyle="sawtooth",fc="0.8")  
# 定义决策树的叶子结点的描述属性  
leafNode = dict(boxstyle="round4",fc="0.8")  
# 定义决策树的箭头属性  
arrow_args = dict(arrowstyle="<-")  

12.matplotlib.pyplot模块中,axis()命令可以方便的获取和设置XY轴的一些属性。
13.Python 字典(Dictionary) keys() 函数以列表返回一个字典所有的键。
keys()方法语法：
dict.keys()
以下实例展示了 keys()函数的使用方法：

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7}

print "Value : %s" %  dict.keys()

以上实例输出结果为：

Value : ['Age', 'Name']

代码

from math import log
import operator
# import sys
# sys.path.append('C:/Users/LRT/PycharmProjects/M_learn/treeplotter.py')
# from treeplotter import *
# if __name__ == "__main__":

#另一个文件的内容
import  matplotlib.pyplot as plt




#使用文本注解绘制树节点
decisionNode = dict(boxstyle = "sawtooth", fc = "0.8")   #定义文本框和箭头格式
#  定义决策树决策结果的属性，用字典来定义  
# 下面的字典定义也可写作 decisionNode={boxstyle:'sawtooth',fc:'0.8'}  
# boxstyle为文本框的类型，sawtooth是锯齿形，fc是边框线粗细 
leafNode = dict(boxstyle = "round4", fc = "0.8")  # 定义决策树的叶子结点的描述属性  
arrow_args = dict(arrowstyle = "<-")   # 定义决策树的箭头属性


# def createPlot():   #第一个版本的createPlot()函数
#    fig = plt.figure(1, facecolor='white')  #先创建了一个新图形并清空绘图区   # 类似于Matlab的figure，定义一个画布(暂且这么称呼吧)，背景为白色 
#    #  把画布清空
#    fig.clf()
#  #  createPlot.ax1为全局变量，绘制图像的句柄，subplot为定义了一个绘图，111表示figure中的图有1行1列，即1个，最后的1代表第一个图 
# #  frameon表示是否绘制坐标轴矩形
#    createPlot.ax1 = plt.subplot(111, frameon=False) #ticks for demo puropses
#   #  绘制结点 
#    plotNode('a decision node', (0.5, 0.1), (0.1, 0.5), decisionNode)
#    plotNode('a leaf node', (0.8, 0.1), (0.3, 0.8), leafNode)
#    plt.show()


def plotNode(nodeTxt, centerPt, parentPt, nodeType):   #绘制带箭头的注解，绘制节点
   # axis()命令可以方便的获取和设置XY轴的一些属性。
   #  nodeTxt为要显示的文本，centerPt为文本的中心点，箭头所在的点，parentPt为指向文本的点  
   createPlot.ax1.annotate(nodeTxt, xy=parentPt, xycoords='axes fraction',
                           xytext=centerPt, textcoords='axes fraction',
                           va="center", ha="center", bbox=nodeType, arrowprops=arrow_args)


# createPlot()

def getNumLeafs(myTree):  #获取叶节点数目
    numLeafs = 0
    a =  list(myTree.keys())
    firstStr = a[0]   # keys() 函数以列表返回一个字典所有的键。
    secondDict = myTree[firstStr]
    for key in secondDict.keys():   #。如果子节点是字典类型，则 该节点也是一个判断节点，需要递归调用getNmnLeafs()函数
        if type(secondDict[key]).__name__=='dict':#test to see if the nodes are dictonaires, if not they are leaf nodes
            numLeafs += getNumLeafs(secondDict[key])
        else:   numLeafs +=1
    return numLeafs

def getTreeDepth(myTree):  #获取树的层数
    maxDepth = 0    #计算遍历过程中遇到判 断节点的个数。该函数的终止条件是叶子节点，一旦到达叶子节点，则从递归调用中返回，并将 计算树深度的变量加一
    a =list (myTree.keys())
    firstStr = a[0]
    secondDict = myTree[firstStr]
    for key in secondDict.keys():
        if type(secondDict[key]).__name__=='dict':#test to see if the nodes are dictonaires, if not they are leaf nodes
            thisDepth = 1 + getTreeDepth(secondDict[key])
        else:   thisDepth = 1
        if thisDepth > maxDepth: maxDepth = thisDepth
    return maxDepth

def retrieveTree(i):   #e输出预先存储的树信息，避免了每次测试代码时都要从数据中创建树的麻烦
    listOfTrees =[{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}},
                  {'no surfacing': {0: 'no', 1: {'flippers': {0: {'head': {0: 'no', 1: 'yes'}}, 1: 'no'}}}}
                  ]
    return listOfTrees[i]


# mytree = retrieveTree(0)
# print(getNumLeafs(mytree))
# print(getTreeDepth(mytree))

def plotMidText(cntrPt, parentPt, txtString):   #在父子节点中填充文本信息
   xMid = (parentPt[0] - cntrPt[0]) / 2.0 + cntrPt[0] # 求中间点的横坐标 
   yMid = (parentPt[1] - cntrPt[1]) / 2.0 + cntrPt[1]  # 求中间点的纵坐标 
   createPlot.ax1.text(xMid, yMid, txtString, va="center", ha="center", rotation=30)  #绘制树结点 

#绘制决策树    >也是个递归函数。树的宽度用于计算放置判断节点的 位置，主要的计算原则是将它放在所有叶子节点的中间，而不仅仅是它子节点的中间
def plotTree(myTree, parentPt, nodeTxt):  # if the first key tells you what feat was split on
   numLeafs = getNumLeafs(myTree)  # this determines the x width of this tree
   depth = getTreeDepth(myTree)
   a = list(myTree.keys() ) # the text label for this node should be this
   firstStr = a[0]  #得到第一个特征    用两个全局变量plotTree.xOff和plotTree.yOff追踪已经绘制的节点位置，
   cntrPt = (plotTree.xOff + (1.0 + float(numLeafs)) / 2.0 / plotTree.totalW, plotTree.yOff)  #计算坐标，x坐标为当前树的叶子结点数目除以整个树的叶子结点数再除以2，y为起点
   plotMidText(cntrPt, parentPt, nodeTxt)   #计算父节点和子节点的中间位置，并在此处添加简单的文本标签信息0
   plotNode(firstStr, cntrPt, parentPt, decisionNode)
   secondDict = myTree[firstStr]
   plotTree.yOff = plotTree.yOff - 1.0 / plotTree.totalD   #，按比例减少全局变量  plotTree.yOff，并标注此处将要绘制子节点
   #因为我们是自顶向下绘制图形， 因此需要依次递减_y坐标值，而不是递增^y坐标值。
   for key in secondDict.keys():
      if type(secondDict[     #如果不是叶子节点则递归调用 plotTree函数,。
                 key]).__name__ == 'dict':  # test to see if the nodes are dictonaires, if not they are leaf nodes
         plotTree(secondDict[key], cntrPt, str(key))  # recursion
      else:  # it's a leaf node print the leaf node   ，如果节点是叶子节点则在图形上画出叶子节点，
         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   #在绘制了所有子节点之后，增加全局变量y的偏移


#绘制图形的x轴有效范围是0.0到1.0, y轴有效范 围也是0.0〜1.0
def createPlot(inTree):
    fig = plt.figure(1, facecolor='white')
    fig.clf()
    axprops = dict(xticks=[], yticks=[])
    createPlot.ax1 = plt.subplot(111, frameon=False, **axprops)    #no ticks
    #createPlot.ax1 = plt.subplot(111, frameon=False) #ticks for demo puropses
    plotTree.totalW = float(getNumLeafs(inTree))
    plotTree.totalD = float(getTreeDepth(inTree))
    plotTree.xOff = -0.5/plotTree.totalW; plotTree.yOff = 1.0;  #将树绘制在水平方向和垂直方向的中心位置
    plotTree(inTree, (0.5,1.0), '')
    plt.show()
#
# mytree = retrieveTree(0)
# createPlot(mytree)
# mytree['no surfacing'][3] = 'maby'
# createPlot(mytree)









#本文件内容
def calcShannonEnt(dataSet): #计算给定数据集的熵。
    numEntries = 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])/numEntries
        shannonEnt -= prob * log(prob, 2) #计算熵的公式
    return shannonEnt

def createDataSet():
    # dataSet = [[1, 2, 3, 'yes'], [1, 3, 2, 'yes'], [1, 0, 1, 'no'], [0, 1, 0, 'no'], [0, 0, 1, 'no'] ]
    dataSet = [[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no'] ]
    labels = ['no surfacing', 'flippers']
    return dataSet, labels

# mydat, labels = createDataSet()  #测试熵的计算
# print(calcShannonEnt(mydat))

def spliDataSet(dataSet, axis, value):#按照给定特征划分数据集  参数：待划分的数据集、划分数据集的特征、特征的返回值

    retDataSet = []
    for featVec in dataSet:
        if featVec[axis] == value:   #将所有符合要求的元素抽取出来。
            reducedFeatVec = featVec[:axis]
            reducedFeatVec.extend(featVec[axis+1:])#extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
            retDataSet.append(reducedFeatVec)
    return retDataSet

# mydat, labels = createDataSet()  #测试
# print(spliDataSet(mydat, 2, 1))
# print(spliDataSet(mydat, 0, 0))

def chooseBestFeatureToSplit(dataSet):     #遍历整个数据集， 计算香农熵和spliDataSet()函数，找到最好的特征划分方式。
#在函数中调用的数据需要满足一定的要求：第一个要 求是，数据必须是一种由列表元素组成的列表，而且所有的列表元素都要具有相同的数据长度；
#  第二个要求是，数据的最后一列或者每个实例的最后一个元素是当前实例的类别标签。
    numFeatures = len(dataSet[0]) - 1   #行判定当前数据集包含多少特征属性。
    baseEntropy = calcShannonEnt(dataSet)   #计算了整个数据集的原始香农熵
    bestInfoGain = 0.0
    bestFeatures = -1
    for i in range(numFeatures):  #。第1个for循环遍历数据集中的所有特征
        featList = [example[i] for example in dataSet]  #遍历第i个特征
        uniqueVals = set(featList)  #set类型：集合数据类型与列表类型相似，不同之处仅在于集合类型中的每个值互不相同
        newEntropy = 0.0
        for value in uniqueVals:    #按各个特征来计算的香农熵
            subDataSet = spliDataSet(dataSet, i, value)
            prob = len(subDataSet)/float(len(dataSet))
            newEntropy += prob *calcShannonEnt(subDataSet)
        infoGain = baseEntropy - newEntropy
        if(infoGain > bestInfoGain):
            bestInfoGain = infoGain
            bestFeatures = i
    return bestFeatures

# mydat, labels = createDataSet()
# print(chooseBestFeatureToSplit(mydat))

def majorityCnt(classList):   #参数：分类名称的列表，返回出现次数最多的分类名称
    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]


# lrt = {'a':1, 'b':2, 'c':3 }
# rgj = lrt.items()
# print(rgj)

def createTree(dataSat, labels):   #创建树的函数代码    输人参数：数据集和特征标签列表。
    classList = [example[-1] for example in dataSat]   #包含了数据集的所有类标签。
    if classList.count(classList[0]) == len(classList):  #递归函数的第一个停止条件是所有的 类标签完全相同，则直接返回该类标签0
        return classList[0]
    if len(dataSat[0]) == 1:   #递归函数的第二个停止条件是使用完了所有特征，仍然不能将数据集划分成仅包含唯一类别的分组©。
        return majorityCnt(classList)  #。由于第二个条件无法简单地返回唯一的类标 签 ，这里使用majorityCnt函数挑选出现次数最多的类别作为返回值。
    bestFeat = chooseBestFeatureToSplit(dataSat)
    bestFeatLabel = labels[bestFeat]
    myTree = {bestFeatLabel:{}}
    del(labels[bestFeat])
    featValues = [example[bestFeat] for example in dataSat]
    uniqueVals = set(featValues)
    for value in uniqueVals:
        subLabels = labels[:]
        myTree[bestFeatLabel][value] = createTree(spliDataSet(dataSat, bestFeat,value), subLabels)#递归调用
    return myTree

# mydat, labels = createDataSet()
# myTree = createTree(mydat, labels)
# print(myTree)


def classify(inputTree,featLabels,testVec):    # 使用决策树的分类函数
    a = list(inputTree.keys())
    firstStr = a[0]
    secondDict = inputTree[firstStr]
    featl = list(featLabels)
    featIndex = featl.index(firstStr)  #使用index方法查找当前列表中第一个匹配firstStr变量的元素0，确定当前用来判断的特征值
    key = testVec[featIndex]    #获取当前输入的特征值
    valueOfFeat = secondDict[key]    #根据获取的特征值进入决策树的下一层
    if isinstance(valueOfFeat, dict):
        classLabel = classify(valueOfFeat, featLabels, testVec)
    else: classLabel = valueOfFeat
    return classLabel

# mydat, labels = createDataSet()
# myTree = retrieveTree(0)
# print(classify(myTree, labels, [1, 0]))
# print(classify(myTree, labels, [1, 1]))

# 使用pickle块存储决策树
def storeTree(inputTree, filename):
    import pickle
    fw = open(filename, 'wb+')
    #决策树序列化
    pickle.dump(inputTree, fw)   #序列化对象可以在磁 盘上保存对象，并在需要的时候读取出来。任何对象都可以执行序列化操作，字典对象也不例外
    fw.close()

def grabTree(filename):
    import pickle
    fr = open(filename, 'rb')
    # 返回读到的树
    return pickle.load(fr)

# mydat, labels = createDataSet()    小测试
# myTree = retrieveTree(0)
# storeTree(myTree, 'classifierStorage1.txt')
# print(grabTree('classifierStorage1.txt'))

fr = open('lenses.txt', 'r')
lenses = [inst.strip().split('\t') for inst in fr.readlines()]
lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate']
lensesTree = createTree(lenses, lensesLabels)
createPlot(lensesTree)

结果

image.png