基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

决策树模型
目录
6 I- S1 ?. L& E* X* E2 J( T6 ^+ C- F人工智能第五次实验报告 1
( u( }3 {2 [$ K决策树模型 1
一 、问题背景 1
1.1 监督学习简介 1
1.2 决策树简介 1
二 、程序说明 3
2.1 数据载入 3
2.2 功能函数 3
9 _; P1 v, a: J* n6 d0 A2.3 决策树模型 4
% m; q6 o& {/ `三 、程序测试 5
; Q- K8 v* c1 |" v  M# E3.1 数据集说明 5
; L' B9 c- E7 I4 P. X# ]. L3.2 决策树生成和测试 6
& M- A# Y- I( u' r' e8 u3.3 学习曲线评估算法精度 7
四 、实验总结 8
9 s* `4 l0 G2 C附 录 - 程序代码 8
一 、问题背景
1.1监督学习简介
机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
. i7 i) `/ v: h  i7 ~- ~5 |; |监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
1.2决策树简介
9 {% ]( Q' N% u' L) O  W决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
决策树的组成
3 d* e5 r% ]* m5 u7 Q) o  f& k决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。

import numpy as np
) s+ i$ j% W. D* m/ R/ Mfrom matplotlib import pyplot as plt
+ D. y. B/ m* u, i: ~from math import log
1 w9 ?5 T3 h6 b! U& c$ Limport pandas as pd
import pydotplus as pdp

9 |% v1 n" h4 B. u( v3 \9 ]"""
7 d, y& O  z( i19335286 郑有为
人工智能作业 - 实现ID3决策树
: g; v6 [& L) n% m"""

nonce = 0  # 用来给节点一个全局ID
color_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
color_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
& D) F7 P4 {$ i" p
2 G: R: d( J& t" T# 载入汽车数据, 判断顾客要不要买
class load_car:
    # 在表格中,最后一列是分类结果
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
  u) ]  Y% B  m- w4 p/ h    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
/ r" z1 k' ~7 [6 }* N/ y        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]
        self.target = data_array[0:,-1]
8 A) O- T+ r/ e" ?: h
# 载入蘑菇数据, 鉴别蘑菇是否有毒
class load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
( o+ {; n- f( K& `    # feature_names: 属性名列表
+ o& i; H/ F: B9 \2 K+ s9 a    # target_names: 标签(分类)名
5 f# J$ z( H( |1 l    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
, _3 P4 [0 p4 M! d) x9 H    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
        data_array = np.array(df)
" d& C  T6 d7 U+ W7 L        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",
                  "stalk-surface-below-ring", "stalk-color-above-ring", "stalk-color-below-ring",
                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
8 v& o0 J8 {  n. t' @9 [6 z        self.feature_names = labels[1:]
        self.target_names = labels[0]
        self.data = data_array[0:,1:]
- T6 l7 Y6 t+ ]# I        self.target = data_array[0:,0]

# 创建一个临时的子数据集, 在划分测试集和训练集时使用
; d* K7 g+ }7 i& Pclass new_dataset:
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
2 ?3 A$ _/ n& O0 j0 Y7 v5 J# {1 f    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
        self.feature_names = f_n
7 [9 G. n. I% [2 T, S, v- x        self.target_names = t_n
6 r( O0 W% x+ K% n        self.data = d
        self.target = t

# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
2 c3 O+ a: f/ |/ Q+ c( D2 X#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
7 ]2 \9 K+ s  A( r, i# target: 分类结果的列表, return: 信息熵
def get_h(target):
, |. y! |) B) N. ~* m! f+ G    target_count = {}
: D) v8 A, F0 f+ _    for i in range(len(target)):
        label = target
4 B$ W% Q. g7 Y; `5 u        if label not in target_count.keys():
            target_count[label] = 1.0
. j0 w, T. I3 d1 A, ~2 h        else:
$ F3 L$ Y& g4 G& e; x            target_count[label] += 1.0
4 h: y  C8 ?+ _* R7 C0 `    h = 0.0
( k5 {7 A$ n& f( [* @    for k in target_count:
        p = target_count[k] / len(target)
) D' d) P$ q1 d8 l9 W; F        h -= p * log(p, 2)
, Q# n0 z+ E- A& R; Z    return h
, C4 Q3 p9 F* E+ U: R. c5 Y
# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
0 t$ t, ~3 X, F# Idef get_subset(dataset, feature_name, feature_value):
    sub_data = []
    sub_target = []
- t9 o1 n: A) r* D) V, ~, r4 `    f_index = -1
# N/ o; N4 G7 A+ _    for i in range(len(dataset.feature_names)):
2 A) R; q% u( I. @) H4 Q$ _        if dataset.feature_names == feature_name:
, k! A1 b$ y+ O( z; m1 Z1 |: F4 J            f_index = i
            break

1 R# h6 c! O' R. ^    for i in range(len(dataset.data)):
        if dataset.data[f_index] == feature_value:
            l = list(dataset.data[:f_index])
, z( j) H0 W7 h1 P& d: E            l.extend(dataset.data[f_index+1:])
7 O7 A' ?- @$ r9 S; i            sub_data.append(l)
            sub_target.append(dataset.target)
( I1 H; x/ }# O! w4 F5 @! `- q
3 }  U5 E2 P5 k* b4 Y3 m0 H  P    sub_feature_names = list(dataset.feature_names[:f_index])
    sub_feature_names.extend(dataset.feature_names[f_index+1:])
% o0 @9 `, O1 P9 F! X7 V- Z- m    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)
" ^' B# h- H  p0 i& y; f
# 寻找并返回信息收益最大的属性划分
2 u' g/ k7 M, {: _0 s# 信息收益值划分该数据集前后的熵减
4 r! Q& h7 @$ o2 l8 R& S7 B. l# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
def best_spilt(dataset):
* y6 G; t+ a/ h  R$ D8 x  ^. A7 A) k
    base_h = get_h(dataset.target)
+ \% q% s; o1 U( }- n    best_gain = 0.0
    best_feature = None
9 @, a+ }+ O! T' t) c, E. R1 g    for i in range(len(dataset.feature_names)):
. h0 o$ a) S% l) }        feature_range = []
        for j in range(len(dataset.data)):
9 _5 r3 H- I) J/ v5 p            if dataset.data[j] not in feature_range:
                feature_range.append(dataset.data[j])

% d+ z0 x9 {$ u7 N        spilt_h = 0.0
        for feature_value in feature_range:
            subset = get_subset(dataset, dataset.feature_names, feature_value)
- P8 Q, Z( y1 M            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)

( _% x! l% l* v1 D: a8 y  C        if best_gain <= base_h - spilt_h:
            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names
! B: ?" N! k; b
% N- ]. q( ~4 @; ?. D' q8 T* y2 H    return best_feature
6 N4 |+ G, I2 P8 r7 t* M
7 K& Z6 p4 m$ O0 D3 x# 返回数据集中一个数据最可能的标签
- J4 \1 Z' t3 Jdef vote_most(dataset):
    target_range = {}
6 b3 [& i. s1 q! x    best_target = None
    best_vote = 0
: n& F& t8 C5 d( {* l# v! {2 e( C
    for t in dataset.target:
        if t not in target_range.keys():
0 f& ^9 B6 q4 f" J& i8 J            target_range[t] = 1
        else:
! }  l" G& {$ m5 B* s            target_range[t] += 1

    for t in target_range.keys():
; b: U' M/ _6 u7 [; k6 N        if target_range[t] > best_vote:
            best_vote = target_range[t]
3 }1 Y2 B! J1 A  t7 C# M/ M3 R            best_target = t
  W* z5 P8 N7 d2 F
" [! @5 V% Y) o& o, D0 H* [0 e: q    return best_target

# 返回测试的正确率
! ]/ h) V, d( U' z8 m0 U/ L# predict_result: 预测标签列表, target_result: 实际标签列表
4 s7 ?: L/ u) h8 r) hdef accuracy_rate(predict_result, target_result):
    # print("Predict Result: ", predict_result)
    # print("Target Result:  ", target_result)
. G/ V$ x, ^; {! {9 }) N; s    accuracy_score = 0
    for i in range(len(predict_result)):
. t8 }: }( w  T6 l) d. r# ^1 b        if predict_result == target_result:
  m1 E5 u. P9 i) h: A            accuracy_score += 1
. H- a. \: d- u7 S7 t8 `    return accuracy_score / len(predict_result)
+ ?1 ^( |$ \; }8 G2 U' ^0 Z9 d
# 决策树的节点结构
/ j" l/ h0 E# V" _! m' ~  xclass dt_node:

    def __init__(self, content, is_leaf=False, parent=None):
* D; F  O2 ~+ G/ I" B        global nonce
& T, X* K5 U$ T4 r4 W% U' L        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
7 d5 K* o/ d; M2 a/ J+ J, d        nonce += 1
; Z5 a* h# z% D        self.feature_name = None
7 M! s& S  ~2 y6 H        self.target_value = None
( d2 p6 b4 B/ _& Z! t: @- D5 Y        self.vote_most = None # 记录当前节点最可能的标签
4 e* k: ^. D9 o( t* {! o- ^        if not is_leaf:
            self.feature_name = content # 非叶子节点的属性名
        else:
            self.target_value = content # 叶子节点的标签
5 y( O6 W9 Z+ |& }& k; x
        self.parent = parent
. A% p2 Z- R2 \* D+ k3 V! `: K        self.child = {} # 以当前节点的属性对应的属性值作为键值
9 @$ D! V3 _" h
% L7 v7 u7 K! }( V1 M. y# 决策树模型
class dt_tree:
9 w7 V' H6 ?! z$ C7 m) t
    def __init__(self):
& v; E; e0 g- ^: r6 m4 B+ Q) V6 v        self.tree = None # 决策树的根节点
        self.map_str = """
7 M; N* P1 U/ T3 l  `            digraph demo{
            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
            edge [fontname="Microsoft YaHei"];
. K7 c# \" x; p. k            """ # 用于作图: pydotplus 格式的树图生成代码结构
        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值
: H; P9 Q4 P( L6 y
    # 训练模型, train_set: 训练集
2 C7 a- i! A! Q" V7 P    def fit(self, train_set):
( B2 Z1 M1 t! Y) D$ r
; d- o9 W$ a* ^) C5 p        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
            return None

6 j6 Z5 Z3 W1 Z& \        target_all_same = True
4 V3 n0 n) [* G        for i in train_set.target:
            if i != train_set.target[0]:
1 w+ m7 w4 I- `" @* o- k                target_all_same = False
& l0 R( m# r* O( B5 U2 i                break
3 h& Z& L. G/ n5 C: w- }
        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
' z: ]2 b, }$ [/ ?            node = dt_node(train_set.target[0], is_leaf=True)
9 R5 D  I" H2 v8 _. M            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.tree = node
1 J, i& \$ f' c: r, h
; o9 ?* c. H% D* [6 K            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
8 ]& t0 m9 S1 y            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"

) }3 ~: D4 P) R            return node
' h3 G# }7 V' |        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
# d6 v6 J4 D! |  j! s2 K. z- \# J                self.color_dir[vote_most(train_set)] = color_set[0]
( i$ D; |4 |4 G1 }; `                self.tree = node

            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
; S+ Y# m+ G! o' V            node_content = "标签：" + str(node.target_value)
0 x  S5 T  H) v% G; v* n            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
. T# A* L4 [2 k! [# w; @
            return node
' o% b$ [/ @. P1 e: P        else: # 普通情况, 构建一个内容为属性的非叶子节点
            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
( ]7 R. G$ b9 o1 _            best_feature_index = -1
            for i in range(len(train_set.feature_names)):
6 G  l- b9 a5 f! ]                if train_set.feature_names == best_feature:
                    best_feature_index = i
; q: ]- T& k; R/ E% s# z                    break
1 i) z& ^' h9 c* S# ~  h
            node = dt_node(best_feature)
            node.vote_most = vote_most(train_set)
            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
                self.tree = node
                # 用于作图, 初始化叶子节点可选颜色
' B1 x. t! e* F( i; V: u+ L+ c                for i in range(len(train_set.target)):
" u- a$ U- C7 `/ x/ |4 T  W  F                    if train_set.target not in self.color_dir:
                        global color_i
% N4 ?  p- M- u. {* ]                        self.color_dir[train_set.target] = color_set[color_i]
                        color_i += 1
                        color_i %= len(color_set)

            feature_range = [] # 获取该属性出现在数据集中的可选属性值
  S0 y7 p, V: F9 C1 y4 u            for t in train_set.data:
( B3 X' O9 o' C  ?2 l4 T                if t[best_feature_index] not in feature_range:
, M! R" d* M! _5 Y                    feature_range.append(t[best_feature_index])

            # 用于做图, 创建一个内容为属性的非叶子节点
( b4 J9 F$ l  }3 V5 }            node_content = "属性：" + node.feature_name
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
( l$ u# U' f/ X. T: F1 X
            for feature_value in feature_range:
6 S% e" Y+ b) k! g( {. D                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
3 Q( d: I- ^9 z                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
                if node.child[feature_value] == None:
                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
* D2 ]5 B# T3 q' t4 {( }                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
                node.child[feature_value].parent = node

                # 用于做图, 创建当前节点到所有子节点的连线
                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"
4 r; t8 N8 [! E* k
/ T/ r2 ]5 T. E            # print("Rest Festure: ", train_set.feature_names)
9 A+ ~2 ?2 q# G: a  [            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
" r* V) V9 v; L$ ?9 g& P            # for feature_value in feature_range:
' B3 Z+ G" Y: B4 p+ J            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
            return node
/ P) v' y+ o3 E. Q' ?
# W/ I# g4 J" o+ Y    # 测试模型, 对测试集 test_set 进行预测
; F% c( y+ `$ v  Y( x0 L, }    def predict(self, test_set):
        test_result = []
        for test in test_set.data:
# @7 G- U' A& ], K! E            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
8 B. W# Y2 [# a1 }            while node.target_value == None:
# S/ _# F2 U* _# U. F                feature_name_index = -1
9 ?- k) H9 J/ I/ O6 M1 N                for i in range(len(test_set.feature_names)):
                    if test_set.feature_names == node.feature_name:
                        feature_name_index = i
                        break
                if test[feature_name_index] not in node.child.keys():
                    break
" H. n: a* h6 n! z0 R0 I' ?                else:
8 r. a3 M+ Z5 T" \; s" a1 \                    node = node.child[test[feature_name_index]]
6 S2 ^( u" V- m$ A" }8 t8 Q
            if node.target_value == None:
                test_result.append(node.vote_most)
) l3 U* C0 M% M+ o" q/ m            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
' M+ J0 I/ }  Z! r                test_result.append(node.target_value)

0 N3 l5 u) y4 v4 f        return test_result
8 E: [2 y" `7 |/ _4 p( D/ R
. h0 Y4 h5 M0 j7 z, K    # 输出树, 生成图片, path: 图片的位置
    def show_tree(self, path="demo.png"):
; I( H9 c  I, v9 @7 ?- U2 o        map = self.map_str + "}"
        print(map)
: R3 Z7 s! P8 z# w3 ^        graph = pdp.graph_from_dot_data(map)
; o! Z, H( }/ O, a( _7 C2 T        graph.write_png(path)
9 P5 ]; h3 l3 @9 V" b
# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
1 p, z1 |' K) C/ X    c = dataset
& Y3 h8 \6 J5 u" f% L+ U    r = range(5, len(c.data) - 1, interval)
    rates = []
0 x! v0 E  N6 }1 c    for train_num in r:
/ S' @. y' n4 a2 ~9 `5 B2 y        print(train_num)
! E( A) n7 h7 u& F+ F: p2 X/ g# F7 H; M        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:])
2 o- ~1 w7 L3 S# |/ u( L        dt = dt_tree()
$ |9 a/ h" M+ c: ^        dt.fit(train_set)
5 ~* a% }! s$ z- Y8 ^$ l, X8 r        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))
! C3 Z& L3 x$ Z
    print(rates)
    plt.plot(r, rates)
    plt.ylabel(label)
/ e) \" e. ~( B' m( J+ A$ y    plt.show()

if __name__ == '__main__':

    c = load_car()  # 载入汽车数据集
    # c = load_mushroom()  # 载入蘑菇数据集
2 r- l8 K' v* t5 n    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
4 x% G" {4 j! U- ]: f    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:])
- X: B& ^  i* ^3 ~! z
    dt = dt_tree()  # 初始化决策树模型
' t. J1 k, m. F8 ]  M" s1 Q    dt.fit(train_set)  # 训练
, t. V  S' S( x    dt.show_tree("../image/demo.png") # 输出决策树图片
/ w! z$ O; L  H# G' [* H% o% ]    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧

    # incremental_train_scale_test(load_car(), "car")
    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)
! P: \% m& i$ ?! o

( {/ n" \1 Y5 V! s* ?* y
% o% D! ~: X* i3 l3 O1 E3 C1
& g0 T3 [! [% o8 C' [2
: G. g! X$ M- f3
( {- |& w% e; z2 I  i4
5
6
2 A$ ~- m- X+ o7
8
9
10
11
/ {7 m( X  T  I12
13
7 s) F1 r0 b) \( @# D14
; w0 r( m4 }# \' Z5 J! n" ~15
16
( Q9 ?4 r) r$ Q" `2 ^, Z17
  q: A: g+ B6 }" }# H18
19
+ e) O& J# k) d) e: Q20
) b' ~& ~! Z3 x& ?& ~, M1 h21
22
23
24
- Y/ B5 l/ p7 x% i3 p* ^25
26
: H3 @1 h2 [7 E7 v# C27
28
29
4 p% Q6 I9 |4 h# ^30
1 w5 b3 _0 w7 {6 f) @) \# m31
; `' g! K! @: u: B( C, D32
3 g. A* m% e! q4 N' h33
5 A' V+ `' r+ u, Q8 }2 i34
35
36
37
' Z& I5 B/ w, _38
39
40
41
42
43
44
- r" [2 k, i. Z5 M; \" z$ s45
46
47
$ w/ h% j" n2 S: ^/ h48
  G3 C1 Q! d6 h+ [9 r5 O- f% N7 d49
5 G& U1 S" M  W. D50
3 b( p- P) F. j. M51
52
; R, c0 ~% C9 ^- q53
, P( E* @% B: R- j54
3 P- ^. R; }9 x' g' h' t55
% e( J& }5 |! }; k1 a( i56
7 \& g3 [7 J6 K: N57
58
$ l8 H7 r' ^# |; @& r) D# `& M) `59
  S# i2 e+ U- Z2 v60
& p+ T0 G( _& l6 T8 T! K# C61
: [: c3 B4 W) q! C62
63
  h: t4 L! G& U0 p9 U  S64
65
66
  t: z: _8 C' ^; b, t! B67
; b0 B$ l' j" C68
3 g5 M  L2 t8 `6 `69
70
# N  u  Q* j4 ]. D71
72
! a) W7 ?+ j" [: m* g5 \73
/ r! a( T  X2 {, L$ E5 X' o1 R74
+ u( x9 f9 W1 ~- [9 B75
76
77
78
79
80
/ _3 }. F2 I" p% o; e5 Y81
( b7 U& N6 m& e82
) H0 }; E5 b+ c# n6 Y$ [  T83
84
85
86
87
6 P( V6 a4 |% T) J: \88
1 W( f( I( h6 Y8 D. m* v, ~89
% H$ d7 o- T5 b) @! w% W6 ^  z90
91
92
: p& Q& W, `6 K0 h# k: T0 E$ P93
94
+ X: i3 W0 t3 j7 H7 i95
  p' x/ e/ X2 q9 f/ W3 |96
8 y, w' W& }: ~+ @97
98
9 H( z, h8 c7 d/ Y99
. J& l# ?0 y& Y; G) _- n1 u100
) b$ o8 d" V% [7 |6 Y3 s101
, k3 j3 P( x8 E& q7 a102
* P; Z( J3 g4 N0 T103
1 g- B( ~- P  I+ e! F2 \104
1 t% F" h3 Y: S) B- M: j105
106
6 @# B. p' S3 w8 ?8 ~107
; f; j( v# W' A108
109
110
8 B1 V1 ]4 b" }1 X111
112
113
* Z8 ~) u+ C# C) G  }* T% _114
115
116
% M0 @, e% `% K6 a( f" C117
/ J" Y( F( K* K+ c" `( S118
' z' ^4 q9 l3 a$ o# {: P119
0 j. k6 m9 b2 V# G. U6 l" N6 e+ r120
$ t% u' M3 v5 z' {7 z) Z* G! n  s121
1 P7 }5 Z0 l: ^122
123
124
125
8 p' m& t& Y4 T126
127
5 i/ W% V' ~- B- L6 w0 t4 @1 h128
129
0 l# j+ L6 ^4 w$ J4 T130
131
132
4 _+ n/ T+ b0 a- X. P133
134
4 Z* k* B. f. ^" _# J8 r+ ]135
3 Y4 v) v0 R- S- j5 I" h136
1 J7 m$ @/ h/ _6 l# P137
9 `2 U$ A- k" C3 y. S  M2 ~138
5 J3 d+ O6 S! F139
4 C& }: x7 @1 @& u, d140
141
+ R5 G) s! k$ ?. ~142
143
8 n9 a2 p& m7 u/ X- r144
145
146
147
. M  Z- g! P' S: |$ Q" K148
149
150
151
& B: }, F2 p, ~5 v2 `$ c7 U. x1 ?152
" R2 S1 s. S7 \9 g2 Y1 B8 ?153
154
155
156
157
4 b1 s1 }) R' q; N+ l$ V158
159
+ ~( y) S0 n) w0 R# N160
161
9 x3 P, l/ O/ p6 T8 t2 L* ]162
8 L) g2 F9 ^7 ^% L+ D' [6 U& e163
164
165
; z3 h5 l# w* w" I& m166
5 }9 Q! j) U; z) ]+ k167
168
169
170
0 c$ l; d; @+ g  Z$ }171
( h9 c) L2 I* H4 T9 E7 w3 o- N172
173
174
- w# U+ z8 P4 a) l8 b* _175
9 F) R: h  S! b* M( k3 ~2 s: k176
+ u. g6 i. Y4 S, O0 j4 a7 [177
178
% `7 b" \& v  x% ?: K179
180
181
2 D6 ~' C# M" V* x* V182
183
. s0 d7 i% @, J) ^; h184
185
* B$ Z* Y* L  d) ~- y% x186
187
5 ?, u4 _+ J# b% @8 D2 o8 K188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
( \: k3 i2 H) M6 }* C204
# U* u& C- u" d1 E# H+ ^205
206
8 R. h9 S. z# S, ]. n; T207
208
4 s# R! ?# O# i& D7 y209
210
+ a- n) i% ~0 K4 x211
212
: z+ |- p: d$ K3 G) R  O" Q213
0 Y* S7 V4 Z5 z* y  o8 m214
215
+ p9 w3 v6 h4 U9 b216
217
! x% }% R& P, {6 x& J4 I218
219
- t  s" k$ P0 O) J6 g2 S220
3 L. Z9 p0 A$ x* R3 j$ F221
+ ~( Y" h/ b0 d; H2 x222
5 Z. @( V" e- S8 @$ D223
224
* J6 ?/ L7 v" \. R2 e2 R225
226
9 x6 U9 j$ r- {, S( ^227
228
229
230
231
2 e5 G  x) I! y+ }! f% v! R; b: o232
! D# k. U5 v% `233
4 ?1 Y. H5 n2 z5 N234
235
! Y8 M8 f: G3 X8 o236
, ]5 N& p# ]7 Q237
238
! j5 R$ k9 j; i, K( E& Q239
240
' h) l. @# y' a241
& \+ N1 `$ ^9 z6 c242
" r& u# J* [. ?243
244
245
' d7 h  _. R0 f  w; U246
2 Q4 ^0 e# u2 F247
2 Z) k" D% M% O( |: |9 M248
0 W2 k( z' a  a' ^, A% d249
$ A& \5 H  x% k/ A+ J250
9 T1 c9 b9 {+ v% F6 I5 g251
252
253
254
255
256
257
. f) D& ?- Q9 L# f: q1 }258
259
260
; b. |5 ]3 G0 T: e7 `4 ^3 x3 k261
; I$ _$ W0 `# `6 P; X8 s0 M262
. r5 q8 k/ V$ ]! O/ _) i6 \263
/ M" ]$ X$ x, U" P& l264
265
" I  ?. Z$ j* A266
  V+ ?; p7 n4 U9 |) l5 V- T# P4 s+ _267
8 U4 Q) i5 x/ g0 R2 H( k268
269
270
271
9 |# N2 i# F: k2 D# F9 V% j272
# Q0 Q4 T$ y! [) O4 b273
274
# `# v. c$ ~- V  e  q5 a: O275
4 o2 h7 M( A6 ]3 x: ]276
277
( E# f# E  N: H278
279
280
" Z4 S5 r) `0 ^8 h281
  Y3 g2 a* u" }! \! B. D) I! y282
, l7 ?4 t+ y* O  B8 j9 k283
284
7 a$ [: d2 e2 W4 R7 O285
286
  `/ e' @$ C* Y2 j. c# c( Y- U287
, B% F/ a6 R  ], ~& g288
, W' D+ ~9 T0 X289
290
8 \* E! g/ G' v) }291
# ~' _% G. c6 G8 k& `( Y) K) {. X292
" d- s- h: x7 T& d' Q3 S& p6 a1 D293
294
295
296
4 g  z% W; ^% }" v9 I+ c297
+ S8 ?$ F/ P8 Y6 R& u7 l# d2 o7 c298
299
300
0 X9 `; |6 I- s0 j301
# P5 ~1 ?6 a, S2 f6 i. Z302
5 Q( L% M& e# t* |303
304
* b- l2 H& p/ o3 S+ \% ]0 D305
306
307
308
; K' s! \5 ?7 B4 o309
310
- q* Q( `  |- e  x- u) ^* o% Q' q311
* }0 C  t. X! D* y312
313
3 h+ W6 s6 Q: p6 A0 d314
315
316
5 q& X. y& Y- \$ ^( @317
& A* x. P* Z" z318
319
320
3 z; A. e! X/ q9 h, e5 |321
6 X& p* ]/ g. z3 ]322
323
# j4 R1 f3 @9 P1 Y' N; Y324
  L4 `3 `! k. x3 G% b: f  K325
326
1 h2 x3 P; s/ S* G  ~9 k! ^327
: f" e  P, p! r( `# c/ n328
% N. X5 l  f5 |5 T5 \9 `329
330
331
4 }0 C: A+ s+ {( t, g9 x

7 k4 ]6 h  }4 G1 q3 U! v1 X
6 ]" G; L* N0 O
+ G7 h; X. q4 H



( H) M$ U8 E. }) w. b7 ~# `8 b


2 b# W) X7 v& q* H. H
————————————————
) x! J: y  u  f版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
+ F5 ~5 O0 q" o7 Y; A0 b: |4 n原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242