1. 算法分析：

A.     ，把数据集的最后一列变为1，2，3，并转换为csv格式。本来没有定义一个TreeNode的类，结果写起来及其复杂，在同学的建议下，建立了一个TreeNode的头文件。

class TreeNode:

dim=0

p=0

left=0

right=0

value =0

def getdim(self):

return self.dim

def getp(self):

return p

def setdim(self,a):

self.dim =a

def setLeft(self,tree):

self.left=tree

def getLeft(self):

return self.left

def setRight(self,tree):

self.right =tree

def getRight(self):

return self.right

def setValue(self,va):

self.value =va

def getValue(self):

return self.value

B.  读取csv文件，将它们存在一个dataset的list中：

def loadcsv(filename):

file  =csv.reader(open(filename,"rt"))

dataset =list(file)

for i in range(len(dataset)):

dataset[i] =[float(x) for x in dataset[i]]

return dataset

C.  计算给定数据集的香农熵ENt =-p*log2p：

def Shannonent(dataset):

numEnt =len(dataset)

labelCounts ={}

shannonEnt =0

for i in range(len(dataset)):

currentlabel =dataset[i][-1]

if currentlabel not in labelCounts.keys():

labelCounts[currentlabel]=0

labelCounts[currentlabel] +=1

for key in labelCounts:

prob =float(labelCounts[key])/numEnt

shannonEnt -= prob* log(prob,2)

return shannonEnt

D.  进行数据集的划分，此处借鉴了机器学习实战的离散数据划分的方法，改成了连续数据的划分，dataset为待划分的数据集，axis为要划分的特征，value为特征的返回值也就是信息增益最大的划分点，输出为以该点为划分的左半边数据和右半边数据，看了机器学习实战上，采用了extend方法：

def splitContinuousDataSet(dataSet,axis,value):

LeftDataSet=[]

RightDataSet =[]

for featVec in dataSet:

if featVec[axis]>value:

reducedFeatVec1=featVec[:axis]

reducedFeatVec1.extend(featVec[axis+1:])

LeftDataSet.append(reducedFeatVec1)

if featVec[axis]<=value:

reducedFeatVec2=featVec[:axis]

reducedFeatVec2.extend(featVec[axis+1:])

RightDataSet.append(reducedFeatVec2)

return LeftDataSet,RightDataSet

E.  现在就要进行选择最好的数据集划分的方法了，传入的参数为将要划分的数据集。首先计算当前数据集的香农熵，之后在每个特征上分别对每个值进行一个熵计算，得到该特征上最大的信息增益的划分点。之后分别在还存在的特征上进行分别计算。把每个特征上得到的最大的记录下来，在把这些放到一起比较，得到整个数据集上最大的。那就将这个特征作为一个划分节点，这个bestValue作为划分值。

返回的是划分的特征和特征值。

def ChooseBestBranch(dataset):

DEntropy = Shannonent(dataset)

bestFeature = -1

bestGain1 = -1.9e+307

bestGain2 = -1.9e+307

bestGain3 = -1.9e+307

bestGain4 = -1.9e+307

bestValue1 = 0.0

bestValue2 = 0.0

bestValue3 = 0.0

bestValue4 = 0.0

if len(dataset[0]) > 1:

feaList1 = [example[0] for example in dataset]

sortFeaList1 = sorted(feaList1)

splitList1 = []

for j in range(len(sortFeaList1) - 1):

splitList1.append((sortFeaList1[j] + sortFeaList1[j + 1]) / 2)

# 计算每个分裂点，得到一个最佳的分割点

for j in range(len(splitList1)):

value = splitList1[j]

newEnt11 = 0.0

newEnt21 = 0.0

LeftDataset1, RightDataset1 = splitContinuousDataSet(dataset, 0, value)

prob01 = float(len(LeftDataset1)) / float(len(dataset))

newEnt11 += prob01 * Shannonent(LeftDataset1)

prob11 = float(len(RightDataset1)) / float(len(dataset))

newEnt21 += prob11 * Shannonent(RightDataset1)

Gain1 = DEntropy - (newEnt11 + newEnt21)

if Gain1 > bestGain1:

bestGain1 = Gain1

bestValue1 = splitList1[j]

if len(dataset[0]) > 2:

feaList2 = [example[1] for example in dataset]

sortFeaList2 = sorted(feaList2)

splitList2 = []

for j in range(len(sortFeaList2) - 1):

splitList2.append((sortFeaList2[j] + sortFeaList2[j + 1]) / 2)

# 计算每个分裂点，得到一个最佳的分割点

for j in range(len(splitList2)):

value = splitList2[j]

newEnt12 = 0.0

newEnt22 = 0.0

LeftDataset2, RightDataset2 = splitContinuousDataSet(dataset, 1, value)

prob02 = float(len(LeftDataset2)) / float(len(dataset))

newEnt12 += prob02 * Shannonent(LeftDataset2)

prob12 = float(len(RightDataset2)) / float(len(dataset))

newEnt22 += prob12 * Shannonent(RightDataset2)

Gain2 = DEntropy - (newEnt12 + newEnt22)

if Gain2 > bestGain2:

bestGain2 = Gain2

bestValue2 = splitList2[j]

if len(dataset[0]) > 3:

feaList3 = [example[2] for example in dataset]

sortFeaList3 = sorted(feaList3)

splitList3 = []

for j in range(len(sortFeaList3) - 1):

splitList3.append((sortFeaList3[j] + sortFeaList3[j + 1]) / 2)

# 计算每个分裂点，得到一个最佳的分割点

for j in range(len(splitList3)):

value = splitList3[j]

newEnt13 = 0.0

newEnt23 = 0.0

LeftDataSet3, RightDataSet3 = splitContinuousDataSet(dataset, 2, value)

prob03 = float(len(LeftDataSet3)) / float(len(dataset))

newEnt13 += prob03 * Shannonent(LeftDataSet3)

prob13 = float(len(RightDataSet3)) / float(len(dataset))

newEnt23 += prob13 * Shannonent(RightDataSet3)

Gain3 = DEntropy - (newEnt13 + newEnt23)

if Gain3 > bestGain3:

bestGain3 = Gain3

bestValue3 = splitList3[j]

if len(dataset[0]) > 4:

feaList4 = [example[3] for example in dataset]

sortFeaList4 = sorted(feaList4)

splitList4 = []

for j in range(len(sortFeaList4) - 1):

splitList4.append((sortFeaList4[j] + sortFeaList4[j + 1]) / 2)

# 计算每个分裂点，得到一个最佳的分割点

for j in range(len(splitList4)):

value = splitList4[j]

newEnt14 = 0.0

newEnt24 = 0.0

LeftDataSet4, RightDataSet4 = splitContinuousDataSet(dataset, 3, value)

prob04 = float(len(LeftDataSet4)) / float(len(dataset))

newEnt14 = prob04 * Shannonent(LeftDataSet4)

prob14 = float(len(RightDataSet4)) / float(len(dataset))

newEnt24 = prob14 * Shannonent(RightDataSet4)

Gain4 = DEntropy - (newEnt14 + newEnt24)

if Gain4 > bestGain4:

bestGain4 = Gain4

bestValue4 = splitList4[j]

if bestGain1 >= bestGain2 and bestGain1 >= bestGain3 and bestGain1 >= bestGain4:

return 0, bestValue1

if bestGain2 >= bestGain1 and bestGain2 >= bestGain3 and bestGain2 >= bestGain4:

return 1, bestValue2

if bestGain3 >= bestGain1 and bestGain3 >= bestGain2 and bestGain3 >= bestGain4:

return 2, bestValue3

if bestGain4 >= bestGain1 and bestGain4 >= bestGain2 and bestGain4 >= bestGain3:

return 3, bestValue4

F.  得到了所有这些东西之后，利用递归的方式构造决策树，传入的参数有待划分的数据集，和当前的树。将划分的特征的信息记录在树节点的dim上面，特征的返回值记录在node的value上。之后分别对左右子树进行递归，得到一棵决策树。关于停止划分的条件有两个，一个是剩下的类别完全相同了，或者是遍历完了所有的特征值，在第二种情况下，需要根据投票majorityCnt来决定当前的分类：

def createTree(dataset, tree):

# if(len(dataset)==0):

# return 0

classList = [example[-1] for example in dataset]

if (classList.count(classList[0]) == len(classList)):

tree.setValue(classList[0])

return tree.setdim(-1)

if (len(dataset[0]) == 1):

tree.setValue(majorityCnt(classList))

return tree.setdim(-1)

bestDim, bestValue = ChooseBestBranch(dataset)

tree.setdim(bestDim)

tree.setValue(bestValue)

leftTree = TreeNode()

rightTree = TreeNode()

LeftData, RightData = splitContinuousDataSet(dataset, bestDim, bestValue)

if (len(LeftData) > 0):

createTree(LeftData, leftTree)

if (len(RightData) > 0):

createTree(RightData, rightTree)

tree.setLeft(leftTree)

tree.setRight(rightTree)

G.  在计算到叶子节点时，如果没有特征再进行划分的情况下，就选择剩下的样本中类数目最多的类，作为该集合的label,在建造树，预剪枝，后剪枝中都用到了这个方法，此处借鉴了机器学习实战:

def majorityCnt(classlist):

classcount = {}

for vote in classlist:

if vote not in classcount.keys():

classcount[vote] = 0

classcount[vote] = classcount[vote] + 1

sortedClassCount = sorted(classcount.items(), key=operator.itemgetter(1), reverse=True)

return sortedClassCount[0][0]