基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型
: t2 U/ p" v' U) k" a
决策树模型
目录
人工智能第五次实验报告 1
决策树模型 1
一 、问题背景 1
1 j0 k9 ?0 m% j' W, K0 B1.1 监督学习简介 1
1.2 决策树简介 1
- q$ M9 w' o/ z/ _, A- T1 S% J3 o二 、程序说明 3
7 r6 t/ E3 I6 r/ t7 C2.1 数据载入 3
2.2 功能函数 3
3 x7 a" C# s% G. W4 {' O2.3 决策树模型 4
三 、程序测试 5
, X7 n- o# q& u& m4 n) l' w& Q3.1 数据集说明 5
3.2 决策树生成和测试 6
$ U9 j6 W. Y5 O9 |3.3 学习曲线评估算法精度 7
7 [% C9 L0 H+ p9 \5 y# Z四 、实验总结 8
& f6 J. i+ y. h& P# r; M附 录 - 程序代码 8
一 、问题背景
1.1监督学习简介
机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
  s1 a  h+ f) Q. i( J$ k* L0 W' Z1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
决策树的组成
8 X9 X+ K2 {9 }决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
+ L0 F0 e* e: s3 g- S% F
5 X1 W& V! K$ I7 nimport numpy as np
+ O# g+ s7 G+ f# bfrom matplotlib import pyplot as plt
from math import log
import pandas as pd
import pydotplus as pdp

"""
1 ~$ P2 E( y6 e19335286 郑有为
人工智能作业 - 实现ID3决策树
"""

nonce = 0  # 用来给节点一个全局ID
" r+ s1 W! E9 N, M4 D- Ecolor_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
" H: `" G2 _! q0 @# scolor_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
' o0 h+ R* ^; v+ m
# 载入汽车数据, 判断顾客要不要买
: D. W9 e# _' t+ t( q' Z6 b2 Wclass load_car:
, f' V7 v5 w1 Q5 O    # 在表格中,最后一列是分类结果
/ g" C6 L) S* e! }    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
7 m. u8 T( @1 l# U3 [        labels = df.columns.values
        data_array = np.array(df[1:])
        self.feature_names = labels[0:-1]
        self.target_names = labels[-1]
        self.data = data_array[0:,0:-1]
  M; j! d& e; U  i# [) ?        self.target = data_array[0:,-1]

# 载入蘑菇数据, 鉴别蘑菇是否有毒
class load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
1 ]; s! _4 \4 G' c    # feature_names: 属性名列表
5 L/ X/ n8 ]% [$ i2 ^    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self):
' k8 F9 S/ |6 u$ N& u        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
        data_array = np.array(df)
        labels = ["edible/poisonous", "cap-shape", "cap-surface", "cap-color", "bruises", "odor", "gill-attachment",
                  "gill-spacing", "gill-size", "gill-color", "stalk-shape", "stalk-root", "stalk-surface-above-ring",
2 K4 z9 v6 F% ]# I                  "stalk-surface-below-ring", "stalk-color-above-ring", "stalk-color-below-ring",
3 H% q' {) X, |' O7 G                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
/ o# p$ r. N4 o! x% L        self.feature_names = labels[1:]
6 {* ]- t; a. q' `        self.target_names = labels[0]
        self.data = data_array[0:,1:]
2 Y! w# y+ Q$ W% e7 K4 V        self.target = data_array[0:,0]
6 g  M, x$ |  @0 B. X2 g
# 创建一个临时的子数据集, 在划分测试集和训练集时使用
class new_dataset:
2 G. V/ ]  ~- X    # feature_names: 属性名列表
. w, E, H5 n% d$ U& d# c, W    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
2 P; o) |7 ~/ }7 N- w+ _        self.feature_names = f_n
        self.target_names = t_n
( C9 l0 d) Y4 K  y& M' s8 H, q        self.data = d
! r( `) s) y7 S        self.target = t

; [9 x6 ?0 V- D( W. @2 d4 W& L# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
' @* i( U0 Z& B9 c1 I5 L1 \# target: 分类结果的列表, return: 信息熵
2 u9 e/ u2 g( v5 j4 edef get_h(target):
3 y% n5 g, }# [4 h    target_count = {}
    for i in range(len(target)):
        label = target
        if label not in target_count.keys():
            target_count[label] = 1.0
        else:
            target_count[label] += 1.0
8 p' Y. q9 |% E/ |/ R    h = 0.0
    for k in target_count:
        p = target_count[k] / len(target)
. G( }. _7 a4 Z1 F4 Y2 E' o        h -= p * log(p, 2)
    return h
2 h/ k+ K. `- I
* z  h  N, l( K" r1 x% K# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
def get_subset(dataset, feature_name, feature_value):
. V" v+ p  c" G2 L9 ^$ b. o    sub_data = []
    sub_target = []
    f_index = -1
    for i in range(len(dataset.feature_names)):
: j; H$ [7 o! a9 s        if dataset.feature_names == feature_name:
$ E* q0 u# l7 U0 O/ b- M& K            f_index = i
9 n% `& r# R, M3 p( f1 r5 j            break

    for i in range(len(dataset.data)):
        if dataset.data[f_index] == feature_value:
            l = list(dataset.data[:f_index])
            l.extend(dataset.data[f_index+1:])
            sub_data.append(l)
            sub_target.append(dataset.target)
9 R+ O& Q4 @0 b/ ]! k& K3 y2 I
    sub_feature_names = list(dataset.feature_names[:f_index])
. {$ {3 U0 a2 @8 X1 J    sub_feature_names.extend(dataset.feature_names[f_index+1:])
    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)

# 寻找并返回信息收益最大的属性划分
1 r" @0 e9 \6 q% z' q( w# 信息收益值划分该数据集前后的熵减
' y: x: D5 Z" S, x# M( l7 L# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
def best_spilt(dataset):

+ q& k1 G+ t! H' o) }    base_h = get_h(dataset.target)
) ]6 ~) @! e3 h2 y. ^* C5 X    best_gain = 0.0
    best_feature = None
    for i in range(len(dataset.feature_names)):
        feature_range = []
        for j in range(len(dataset.data)):
            if dataset.data[j] not in feature_range:
9 m3 j+ h- Y! f& W+ W, B: [  B                feature_range.append(dataset.data[j])
$ c4 }! l" M" C+ z, Z: }
1 A! x9 u  Z" E; E/ [7 A        spilt_h = 0.0
* p: x8 Y. s6 D( [        for feature_value in feature_range:
2 K6 g: v$ }0 g% I            subset = get_subset(dataset, dataset.feature_names, feature_value)
) ]1 X. w6 B3 i$ J7 q9 M7 H            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)

        if best_gain <= base_h - spilt_h:
            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names

    return best_feature

# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
( w2 A  {4 o- m. C; g    target_range = {}
    best_target = None
    best_vote = 0
+ N' x, }* c! L3 P/ X  b
    for t in dataset.target:
3 F# i5 U, U4 f. W: W. ?        if t not in target_range.keys():
* g  J. `! @8 v, \; D( a            target_range[t] = 1
' z- q/ `. y" U  t" n( n" j        else:
            target_range[t] += 1
# \/ M& `  s  W7 N. o" K* @" U( V
    for t in target_range.keys():
        if target_range[t] > best_vote:
            best_vote = target_range[t]
/ l2 g2 c+ e3 ]% n            best_target = t
; Y5 h7 T" Z+ \' s7 q
    return best_target
$ y1 X& @( N( _$ \/ `0 }7 h
# 返回测试的正确率
# predict_result: 预测标签列表, target_result: 实际标签列表
def accuracy_rate(predict_result, target_result):
    # print("Predict Result: ", predict_result)
    # print("Target Result:  ", target_result)
" S7 c" N7 y2 Q6 Q7 V3 `    accuracy_score = 0
    for i in range(len(predict_result)):
        if predict_result == target_result:
) K9 q+ X4 ^4 V" Q& T; A            accuracy_score += 1
9 g* y4 l  \: F+ h; x    return accuracy_score / len(predict_result)
' I6 K3 r+ A  R  E- `
* W* i/ }) F0 J1 d9 n. I4 ]# 决策树的节点结构
class dt_node:

    def __init__(self, content, is_leaf=False, parent=None):
0 Z5 \0 Y0 Y1 i4 w( f3 I+ q' q        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
        nonce += 1
        self.feature_name = None
        self.target_value = None
        self.vote_most = None # 记录当前节点最可能的标签
        if not is_leaf:
, }1 H  @# Z( }5 A# `( b. I% N            self.feature_name = content # 非叶子节点的属性名
        else:
            self.target_value = content # 叶子节点的标签
/ u9 d: y  D8 X) `3 d
* ?9 M) o9 Q$ I4 W2 W6 v- x* c- T( g        self.parent = parent
/ j6 S- ]8 o9 T- i1 S7 ]        self.child = {} # 以当前节点的属性对应的属性值作为键值

4 Q% s0 ]  T6 @! i  I$ I! ^4 t# 决策树模型
) |+ g* c3 A6 i" H4 J) T, Mclass dt_tree:

    def __init__(self):
        self.tree = None # 决策树的根节点
        self.map_str = """
4 M; Y2 `( {# w* j8 L            digraph demo{
            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
            edge [fontname="Microsoft YaHei"];
( [# `! W( Q0 ^, O$ i            """ # 用于作图: pydotplus 格式的树图生成代码结构
+ b. i* x& h' N* F        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值

% u( q$ Q# _( `# U. ]    # 训练模型, train_set: 训练集
    def fit(self, train_set):

        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
5 I7 |; ?4 E7 A+ E, w            return None

6 E. E  e2 E8 t) v6 w1 @        target_all_same = True
        for i in train_set.target:
; f& E2 h+ C' T# K6 X* S            if i != train_set.target[0]:
7 k" U  t  u$ ^, x' k                target_all_same = False
                break

        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
            node = dt_node(train_set.target[0], is_leaf=True)
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
3 j. N. h# r0 k+ q8 M% |- u                self.tree = node
! f9 I8 V+ a" `' D& b/ Z
            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
) t6 q% D2 L4 C6 ~6 f; g            node_content = "标签：" + str(node.target_value)
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"

0 r- B+ u% K# G; x            return node
        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
8 [+ E9 M0 ~3 m( E                self.color_dir[vote_most(train_set)] = color_set[0]
                self.tree = node

            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
3 l* c$ j3 \! l' \9 N            node_content = "标签：" + str(node.target_value)
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"

            return node
' ]1 c0 t8 D. f- ]        else: # 普通情况, 构建一个内容为属性的非叶子节点
            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
8 b# @& u) R% z1 c, x            best_feature_index = -1
6 z" E, J! d2 i7 y+ }            for i in range(len(train_set.feature_names)):
                if train_set.feature_names == best_feature:
8 E$ M- O3 f/ o* P/ z# h1 C                    best_feature_index = i
5 g$ m; x  ~5 b6 [" g. x/ S                    break
, M: ~) e# _- k3 R& K8 _6 j2 J
            node = dt_node(best_feature)
/ x; e+ l0 D" T% o  j3 N            node.vote_most = vote_most(train_set)
            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
                self.tree = node
                # 用于作图, 初始化叶子节点可选颜色
                for i in range(len(train_set.target)):
6 V* N& A8 M6 }3 C7 J4 P% L5 I                    if train_set.target not in self.color_dir:
8 W4 _# i4 B' {$ R) u4 @' ^                        global color_i
+ @7 o& ^' ]7 s' Z( a8 B; F' m                        self.color_dir[train_set.target] = color_set[color_i]
                        color_i += 1
4 l5 d) m" u5 p- A/ x                        color_i %= len(color_set)
- k- l1 o: \- m" m, Y8 y
            feature_range = [] # 获取该属性出现在数据集中的可选属性值
            for t in train_set.data:
/ x& _; g# U% H4 K) c                if t[best_feature_index] not in feature_range:
                    feature_range.append(t[best_feature_index])

            # 用于做图, 创建一个内容为属性的非叶子节点
            node_content = "属性：" + node.feature_name
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"

            for feature_value in feature_range:
' a* n' L( V0 j: T0 F6 I                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
3 s+ i1 \/ ?: c* J1 D6 X8 O                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
8 K' k& x; j& A: @- P# G                if node.child[feature_value] == None:
                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
( z: G) G, D# ]6 g                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
# I2 \, G! d/ y4 |% t. T                node.child[feature_value].parent = node
) [. `6 p5 B( i  `
                # 用于做图, 创建当前节点到所有子节点的连线
                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"

            # print("Rest Festure: ", train_set.feature_names)
            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
) h$ ?9 m- }0 S5 b' H            # for feature_value in feature_range:
            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
            return node

    # 测试模型, 对测试集 test_set 进行预测
    def predict(self, test_set):
        test_result = []
) W* ?, d* G3 {8 @% o. n; G+ z        for test in test_set.data:
            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
            while node.target_value == None:
                feature_name_index = -1
+ O) T1 I* v, U0 R! u8 i                for i in range(len(test_set.feature_names)):
: i2 g$ V% r$ P0 ]1 Q                    if test_set.feature_names == node.feature_name:
                        feature_name_index = i
                        break
/ n; r5 `3 H- E1 P/ N                if test[feature_name_index] not in node.child.keys():
                    break
                else:
- d( P+ T7 ]6 a' `8 J                    node = node.child[test[feature_name_index]]

, ^  j: \! g9 U, B5 @4 e            if node.target_value == None:
                test_result.append(node.vote_most)
3 q; b  d7 B3 q9 F/ N% x2 D8 Y            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
                test_result.append(node.target_value)

        return test_result
( t2 w' M2 G7 w
6 v9 T- e7 C% F2 t    # 输出树, 生成图片, path: 图片的位置
1 l. X5 r  c* i! A' E4 p/ T- ?    def show_tree(self, path="demo.png"):
8 v7 S2 F( }$ |        map = self.map_str + "}"
        print(map)
        graph = pdp.graph_from_dot_data(map)
. A1 g* T# E, X. }0 s' K0 w        graph.write_png(path)
5 p' o# I, p: i
# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
    c = dataset
: z  A. C, W5 ]; U" {! M    r = range(5, len(c.data) - 1, interval)
    rates = []
9 A& d' m! m3 o7 y4 z2 `2 A    for train_num in r:
7 t7 O9 u# l1 w0 X1 p7 r, x" L( u. ?4 B: ?        print(train_num)
' j9 H$ u* s' ?        train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
4 v. y9 S$ W' Y! Q$ f3 u1 D3 Q        test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
8 [! |2 x7 @/ \3 y; \* m        dt = dt_tree()
0 G8 g3 y4 t! v; a" j        dt.fit(train_set)
% }) J% f) A& a- S# C        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))
5 _6 k0 x% ^+ o; M% p- k8 c
    print(rates)
    plt.plot(r, rates)
    plt.ylabel(label)
9 J1 C/ [( p! e  f    plt.show()
6 J- v) ]8 [  M! W6 s
if __name__ == '__main__':

    c = load_car()  # 载入汽车数据集
1 ]1 J! A( W0 K! H. N  ^: G    # c = load_mushroom()  # 载入蘑菇数据集
; m" i; l7 I8 }( K8 ^/ `    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
    train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
    test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])

. B  U  S4 B/ `    dt = dt_tree()  # 初始化决策树模型
    dt.fit(train_set)  # 训练
8 _- \" g4 q$ Z/ o; h    dt.show_tree("../image/demo.png") # 输出决策树图片
    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧
' ~1 ?( V7 K9 V- Q4 Z1 e, y' H
3 H  M$ f. c6 Z. l8 O    # incremental_train_scale_test(load_car(), "car")
    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)
% d6 t% c: ?9 w
, s- C0 q% E6 q& i- B0 h# v; [  a

* b" c5 S( j! w4 R4 b/ D) F1
2
0 y$ b) @! |- M( U" f; A# U" B/ o6 \5 m3
4
2 Z+ J3 x5 j$ `& g9 l  F0 v7 g5
; T; f( S$ i+ d" o# {6
/ {, T* H  f5 Q8 Z* H7
2 W& U' [) c) Z- ^) [8
4 t5 I3 v, F5 @* o9
10
11
12
13
14
) u* A* r/ H7 k7 [1 y5 n2 O15
16
17
18
, }& h$ Z" u2 r0 a19
20
; @! d' @# Y! R% D# c" x. J! b8 q, |21
8 T+ Q$ {$ Q0 y* M- p6 S22
23
4 a5 ]  t9 Q" I( _4 e24
3 O; J  J( r# K" H25
26
6 A, |- a! n! n( p27
28
29
3 l; |2 N1 p# y  k! l. ~; z) C4 E. E30
31
/ F" N6 t( X$ U& U  f4 n+ L32
33
34
. o0 s! C7 {. V, ^" \/ q7 S35
36
" a& P' N2 V% l1 V1 }; F37
38
; d3 W0 e4 Y3 `7 K39
40
$ f* `0 t8 r# g41
0 D2 N7 W! e+ {6 L42
43
44
45
  v7 n3 B! @5 i8 H/ N5 ?' A- t46
2 D" D: E- `9 ^5 X% e; }3 R47
48
49
" D1 C9 N% L: l3 n50
) z6 G6 i7 n, t$ w, s51
7 B; M3 b6 A# |2 |# i52
53
54
' ]$ F# o0 B. {. l1 C/ o55
56
57
58
59
60
1 _7 }- _7 X7 ^8 P" M" P61
/ P8 _+ \' B  i: y62
63
1 H% L1 y- G2 D, r# W3 [' H64
; F9 Q* H# S5 ^/ E0 ]/ M65
66
67
68
, i9 D1 U& V/ \2 e, L69
2 `; {% _6 D" `3 n/ m70
71
72
8 P6 `* C! ?1 @* `- F73
74
3 k. _4 i" g! N  M) L75
) i/ k# `+ {' ~' i: ~5 {1 v76
+ d/ G# ~+ C6 R3 Q1 O3 a77
1 m* l7 h6 ]- v7 ~78
79
80
& V4 z0 U! z+ N81
1 T% J8 z" q( Q/ h82
83
84
) X8 P/ @  L1 X85
86
# v  n) K1 g4 l: {) L87
88
8 k$ k- ^! X7 w) \5 U, G' z' H% D4 T89
7 S+ p/ q) `) C2 F90
91
" _; l! f4 n' Z+ _92
93
  i. j/ q6 s+ p- R* Y94
95
: N/ p0 F# R2 \2 [# n96
97
98
1 b9 e/ Z4 n2 U5 m99
100
101
102
7 l4 q, }) a) t; T* R9 l103
9 N1 ^9 A6 X  n5 u7 q% D104
105
106
107
108
109
# S6 }* ~: L4 L+ O110
111
0 x% G2 g0 Z0 ~' _1 @2 g8 Z112
113
114
115
1 ~8 H- _  ^- x  j% x% I116
  _# n; n5 {8 b- ^117
118
119
120
121
122
123
124
125
126
2 V5 d6 y9 e9 \1 Y, q  X127
' n' B* K0 t. s* v128
: R$ x; T7 ^- H1 n, B129
130
+ [2 a& l( M0 q/ Q! [- c3 o131
& M; R/ \: F+ g4 h. D+ w/ p9 ~7 [! n132
0 m, P0 l& j% l  s133
$ }9 ~3 M8 C$ i3 w134
/ e: U; j$ B; d+ ]# I% W1 b: M135
136
137
138
, i# [( C( t# c0 F# E  e& i! U139
5 j/ ]. X% I& b! U/ [140
141
8 M. g1 E" b! E0 a142
143
/ x$ L9 M+ ]  J' C0 y8 T8 `144
145
146
147
148
149
7 U, d- x+ b5 D, x0 y# A0 z150
151
; }& r7 D% T* p) N152
153
, z  F5 T$ m! j5 z# J/ s154
155
156
9 l$ I# z( s0 u" y8 J157
: p5 H  i  k/ V4 S# y* w% X8 k' q6 }158
159
160
161
$ L0 J8 H0 h# T5 F% H162
163
0 y7 ^7 c: D/ s. C164
" L+ |) u0 v+ x/ F165
166
167
168
2 D3 h. G# H  L169
1 M2 b: r3 i" H; ^# R170
171
172
1 A& u- H! b$ P0 V6 ?) ?7 K173
9 ?5 Z0 C, m+ @3 Q" ^174
175
( X& Z2 ?% x3 r& f" T176
177
# h. B' }) C" G178
179
180
. H) }/ Y/ [7 F# P7 s181
/ t$ x2 }" F) L! o) b* r& b8 j182
# O# J9 ~  ^- e5 ~183
184
0 M5 ^$ z( W; P. s3 ], E3 f$ c8 y185
186
187
) S- l7 p0 c( x6 |, J, B: i188
189
190
! K# F9 b, h8 h$ k191
192
) Y0 f2 W! h/ h8 \193
- v0 W+ W5 g" }- q194
: t' X3 O- M: H3 [  N$ B1 T" e195
196
8 S# }4 t+ m9 A+ K3 I5 A0 ?197
198
199
200
+ ^5 @2 M) q. X3 l& [# M7 }& ]0 w6 Z201
' h; A6 T* z- O. P& O202
203
( m& ^8 r. D9 f0 u6 U' d" L1 E204
1 ^9 n3 l, J8 d. t9 B% U# E: k205
206
207
208
209
% _! H! f. F/ l+ S3 Z# `210
' m1 \8 S2 M% L$ ^$ g211
212
213
8 l( ]7 I; {! t4 y2 f214
) s$ _' _3 h, E0 k- I$ F0 q; j215
216
( J5 C- B: Y/ k2 v7 S0 ^217
' V% \' n2 l! L+ U218
( w3 c5 R) \7 E% t- h9 K219
220
3 Z2 O# a/ E2 G& t7 d7 U221
9 ]+ a( }: O! X. G222
6 n' R) ~0 V. Z, @223
224
225
226
227
228
& A- e8 M0 u4 P* u" ~& U229
230
. x( C; A, m7 c& c; s1 q4 e231
232
6 p, E$ b* m/ }233
  x4 ?! _1 P- Q+ h& P9 b234
. \& A8 K) X  M4 }235
3 \7 [- A6 |6 y# k+ |6 @236
) R' p$ ]6 o$ p- i, j237
5 P: T# Y- B% q238
239
240
& ?. w+ [' Y0 I. x3 b6 y241
* ?# x2 O; N3 v3 o" O242
) t! [# m# i: N. g9 p5 p243
244
245
/ S- q" i9 j2 }( S+ @246
5 n8 U( u" a# i3 B# `" ?247
/ X/ Z4 Y7 r$ y! U: y# ?248
249
2 W  k7 ~+ L* I$ _7 H$ p250
251
252
# S- T; Y4 W4 K, {7 k+ `! h253
254
255
256
& C- L  B5 b# Q8 F257
$ `! I4 D: {$ f  E* @258
! Q' t/ _0 s5 ~/ A! b259
260
261
262
9 S+ J; ?6 q( K$ E# x& _  b263
264
6 }& v. t% t. }# ^" s265
: H5 r, U/ s% N) h! q' m266
- S. y) ?: E* D- T0 |( b267
268
9 _1 u- I) J+ O4 o269
270
6 R4 n( Z% x0 u3 w/ [271
272
273
274
/ ?. _% h' z; ]9 t8 X) m275
0 r6 M& j* q9 r2 g) o# b276
277
278
279
4 X$ V$ N: [* o# R, e280
3 B9 f, }- e7 ^$ G* X9 W3 k8 Y% o/ F281
& Q# O) d2 K/ V6 u  z5 J282
( H8 v* X) ]# g% j& Z; X- @& D  w7 f283
284
$ I4 x2 b5 s) n285
286
287
4 D/ P% @$ Q. H, u5 M0 m% Q288
289
# ^) Y+ D  u" F9 Z' U+ q- t- Q290
291
292
0 C. {9 W+ U3 L2 o) Y293
294
295
% J0 Z. _6 W# o* T7 y296
/ L( E$ Z/ r' t- x: ^3 e6 i297
298
299
( H0 i+ P2 B* k3 x  K. x300
7 [* `# \, K1 v% O! x: P301
302
2 ]! T& `" h& z/ H( S303
) @: Y1 [" K: E$ f2 z304
305
' h% s% s! z: H/ t, c" ~. `306
7 r9 W2 P3 j  h3 Y. f* Y6 t307
& c* a8 {6 R' T# U, d& @308
309
/ @, j1 l+ m( ^+ z( t310
311
312
+ h. v3 K- _! M8 z313
/ Z9 J: Y4 u" M314
315
316
# {4 D2 d- M5 V% O# X  L  h( o3 m317
8 E3 e; l1 o4 k1 r  L8 h( h318
  j) Y+ Y! X8 o319
+ D) S  ]4 e8 J! R320
* O9 R- v3 ^4 W7 T' ~9 E321
322
$ i9 T9 u2 x( t5 S+ z7 O323
" C  |! z' o- q, y, x9 Q324
325
326
327
328
329
4 s* O' F3 f0 u330
331








8 ~# |9 I, n+ [& e

' X1 u' }8 `& c1 m+ t5 h* d8 K$ V3 }! [
/ G# j: v7 W$ Y: W+ x7 U# x0 l
————————————————
版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242

- n4 |) e# F8 w8 o1 w