一、计算机是如何工作的
        首先我们要明确一个概念，就是计算机本身并不知道自己要做什么，这些要做的事情需要我们去告知计算机，这就是程序代码。早期的时候计算机每次只能做一件事情，他需要知道的是干什么，怎么干。这就是程序代码要体现的，程序的基础目的在于有一个输入（数据）然后经过处理（怎么干）得到我们想要的输出。从计算机的逻辑层面来说就是处理器需要有输入然后经过里面的一些运算器件得到输出。
现代计算机大都采用了一种叫做冯诺依曼的结构，叫什么不重要，这种结构的意思就是我们现在所说的程序和数据都储存在一起。所以计算机在运行的时候需要从中将数据取出，然后用程序进行处理，最后得到输出。所以给计算机编写程序代码的时候也是要关心一下三件事：
1.程序要处理的输入数据； 
2.程序如何处理数据； 
3.程序处理后的输出；
所以在编写程序时候需要做的就是告诉计算机需要处理哪些事情和如何处理以及要怎样输出结果。我们用以下面的代码作为例子：
int g(int x){
  return x + 8;
}
 
int f(int x){
  return g(x);
}
 
 
int main(void){
  return f(8) + 8;
}
我们看到，上述程序需要处理的数据是一些整数，处理的过程是调用f() 和g()连个函数进行运算，其中f(x)=g(x);g(x)=x+8;处理的结果就是返回f(8)+8这个值。但是高级语言是计算机不能直接看懂的，计算机智能看懂0101的机器语言，所以上述C语言代码必须经过一个叫编译器的东西翻译成一种可以和0101机器语言直接映射的语言——汇编语言，这样计算机就可以执行你写的代码了。
二、X86汇编简介（AT&T格式）
  和我们使用的高级代码一样，汇编语言的指令也是需要知道数据，处理，输出三个要素，只是这里面我们把他们叫做原操作数，指令码，目的操作数，具体的格式如下：
 我们看到上述指令中要处理的数据是%esp，要输出的数据是%ebp，要做的处理是movl这样一种处理。意思就是将%esp寄存器中数传送到%ebp寄存器中。上面这就是汇编语言指令的基本形式。现在在linux系统中我们可以利用vi + [文件全程] 创建一个c代码文件。比如在命令行中输入vi exp01.c 进入新建文件，这时按字母i，表示开始编辑。将上述c代码黏贴到文件中如下图所示：
上图中我们看到代码粘贴之后我们按esc按键退出编辑模式，再输入“：wq” 表示保存退出。然后我们在输入ls命令查看目录下的文件发现已经有了我们之前插入的文件。这个时候输入gcc -S -o exp01.s exp01.c -m32 将要翻译的exp01.c文件翻译成上述的汇编代码（翻译的成32位汇编指令）用于再次翻译成机器码执行。
然后我们看到已经翻译成功然后再次使用 vi exp01.s 命令编辑这个文件如下图:
上述代码中，我们看到有很多看不懂的以。我们将他们去掉之后和C做一下对比：
  我们看到从上面的汇编代码和C语言对比中我们可以看到一些规律，首先C语言中的函数名称被翻译成了一其名字开头加“：”的一段代码。而每段代码的开头我们都看到了相同的两段汇编语句。
pushl	%ebp
movl	%esp, %ebp
上面两行实际上是对内存堆栈的一个操作，我们知道程序执行是需要内存的，所以每次有新的函数过程被调用的时候计算机也必须分配一段内存给他来运行。那么具体是那一段内存呢。实际上就是%ebp+%esp所在的地址，为了分配方便实际上我们把%esp叫做叫做堆栈指针，而每一个函数都有自己的内存空间也就是堆栈，不同的函数堆栈是由%ebp标注的，这里面我们把它叫做堆栈的基地址，就是一个堆栈开始的地方，然后内个堆栈中存放了函数运行需要用到的一些数据，这些数据就有堆栈指针寄存器来标定%esp。所以每个代码段或者说函数段在运行的时候都会保存上一个运行的函数的基地址，用于它运行完之后返回到调用它的那个代码段的地方。然后在将自己的堆栈其实地址放入到基址寄存器中之后就可以开始自己的代码运行的了，这就是上述代码的意思。
</pre></div><div><span style="font-size:18px"></span><pre name="code" class="plain">main:
 
	pushl	%ebp
	movl	%esp, %ebp
	subl	$4, %esp
	movl	$8, (%esp)
	call	f
	addl	$8, %eax
	leave
	ret
f:
	<span style="color:#ff0000;">pushl	%ebp
	movl	%esp, %ebp</span>
	subl	$4, %esp
	movl	8(%ebp), %eax
	movl	%eax, (%esp)
	call	g
	leave
	ret
这段代码中我们开到红色的部分就是函数进入和返回时后的固定代码，上面已经分析过他的作用。看这段代码在做完例行工作之后首先是将%esp进行subl操作，就是将esp减4。实际上我们发现main()函数和f() 函数都进行了这个操作是因为他们都需要进行函数的调用，所以我们可以知道这个语句的意思要预留一个位置给其调用的函数传递参数。然后第二句话就是讲8这个立即数传入到里面之后，运行call f 意思就是呼叫f函数，就是调用f函数这个时候我们看f函数的代码。
除了例行公事的红色部分我们开到f也为其调用g时候要传递参数预留了一个位置就是使用 subl$4, %esp，然后调用movl8(%ebp), %eax找到第一个穿进去的参数。（就是那个8——>f(8)）为什么呢。我们来分析一下他的堆栈结构：
首先我们看到main函数中首先保存了当前的堆栈基地址（ebp-0入栈了esp-0向下移动了一个单位-4到达esp-1），然后将ebp-0移动到esp-1的位置成为ebp-1然后esp-1再向下移动一个单位到达esp-2，保留这个位置用于保存其调用函数的返回值，这个值在那个函数中用eax来传递后面会讲到。然后将调用f函数时候需要传入的参数8放入堆栈中esp-2指向的位置。然后调用f函数，这个时候需要先保存一下当先的ebp，也就是epb-1。
然后来到了f函数中，首先也是将ebp-1入栈然后将ebp指向当前esp-4的位置（每次伴随入栈操作都会影响esp的值）到达ebp-2，然后esp在向下移动一个单位到达esp-5。留出一个返回值的位置然后将当前ebp+8中的值传入eax用于返回。然后将eax中的值传入esp，然后重复上述过程调用g函数。g函数返回16，然后到f中，f也返回16。然后回到main中执行addl $8,%eax。最后的结果是24。
三、函数堆栈使用与切换以及操作系统中的任务切换原理简析
上述过程实际上演示了函数之间调用的大体过程。下面对这个过程进行简单的总结。我们可以想象每个被调用的函数使用的内存空间都大体上先包括这么几个部分：
1.函数的运行所用参数（C语言中的函数参数列表）
2.函数的运行过程中产生的数据（运行的中间结果和返回值）
3.调用它的函数的入口地址
4.保存它调用的函数的返回值的空间
所以对应的调用别人函数就要传入入口参数，就是比如f(8)中的8就是这样的入口参数（实际还会复杂一些）。
那么我们可以类似的退出操作系统中如何切换任务。实际上每个任务也会分配各自的运行空间，那么在任务调用的时候，一个任务需要得到他的内存他的运行参数才能开始执行。就像函数一样。可是现在操作系统中的任务是异步的（就是你也不能确定什么时候会调用什么任务）所以这个时候如过一个任务执行到一半，需要执行另一个任务的时候。就好像一个函数要调用另一个函数，这个时候我们怎么保证它返回之后还能继续运行呢，参照函数的做法我们至少要保存当时即将跳转时候的运行地址，但是这是不够的。如果函数比较发杂有很多中间结果在寄存器中，这个时候另一个函数要运行，这些结果也要保存起来，因为新的函数可能会覆盖这些寄存器。类比我们就知道在任务切换的时候我们也要保存当前跳转之前的运行地址，这个任务运行中产生的数据，用于恢复这个任务时候继续刚才的状态继续运行。这些数据我们叫他上下文也好，现场也好。实际上就是他的所有状态的集合，这些数据用于当系统再次调用它的时候恢复它。
首先恭喜您，能够认真的阅读到这里，如果对部分理解不太明白，建议先将文章收藏起来，然后对不清楚的知识点进行查阅，然后在进行阅读，相应你会有更深的认知。如果您喜欢这篇文章，就点个赞或者【关注我】吧！！

0. 写作目的

好记性不如烂笔头。

1. 计算AP（Average Precision）的理论知识

对于每一类目标检测给出的置信度（Confidence），首先按照Confidence降序排列，然后将交并比（IOU）>0.5的当做正确预测的结果，否则为错误预测的结果。然后依据预测结果的正确与否计算TP(True Positive), FP(False Positive), FN(False Negative)，TN(True Negative)，依据TP, FP, FN， TN来计算召回率（Recall， 查全率）和精确度（Precision， 查准率）。

                                                                  

                                                                      

我们平时所说的Accuracy的计算公式为：

                                                               

然后依据Confidence排序后的顺序依次计算出Precision和Recall，理论上AP的计算为，由Precision和Recall构成的折线图的面积，但在实际计算时，主要有三种计算方法。

三种AP的计算方法：

1） VOC2007的11Point方法(MAXIntegral方法)

2） VOC2012 Integral方法（Natural Integral方法）

3）coco的计算方法

这三种计算AP的方法只是在积分上有不同，计算方法是类似的。11Point方法是在MaxIntegral方法中找到11个最大的Precision，然后结合Recall = [0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]，绘制出P-R曲线，并通过如下公式计算出AP：

                                                          

对于MaxIntegral的方法是：计算所有的MaxPrecision的值，然后进行相加求平均值。

对于Integral的方法是：直接对曲线下的值进行积分（当然实际计算是也是采用相加来积分的，不仅仅是11点，针对每一个precision下降的点都加入计算，计算方法与11点的类似，只是分母不再是11了）。

另外还有COCO数据中计算AP的方法，采用的是IOU（用于决定是否为TP）在[0.5 : 0.05 : 0.95]计算10次AP，然后求均值的方法计算AP。

主要介绍11Point方法[3,4]。 

在11Point中具体如何查找这11点的MaxPrecision，可以参考ssd(caffe版本)的代码[1]（在bbox_util.cpp中的ComputeAP函数中），这里直接给出代码（以下代码中vector<float>* temp是博主添加的[2]，用于输出每个类的MaxPrecision，然后绘制P-R曲线）：

void ComputeAP(const vector<pair<float, int> >& tp, const int num_pos,
               const vector<pair<float, int> >& fp, const string ap_version,
               vector<float>* prec, vector<float>* rec, float* ap, vector<float> *temp) {
  const float eps = 1e-6;
  CHECK_EQ(tp.size(), fp.size()) << "tp must have same size as fp.";
  const int num = tp.size();
  // Make sure that tp and fp have complement value.
  for (int i = 0; i < num; ++i) {
    CHECK_LE(fabs(tp[i].first - fp[i].first), eps);
    CHECK_EQ(tp[i].second, 1 - fp[i].second);
  }
  prec->clear();
  rec->clear();
  *ap = 0;
  if (tp.size() == 0 || num_pos == 0) {
    return;
  }

  // Compute cumsum of tp.
  vector<int> tp_cumsum;
  CumSum(tp, &tp_cumsum);
  CHECK_EQ(tp_cumsum.size(), num);

  // Compute cumsum of fp.
  vector<int> fp_cumsum;
  CumSum(fp, &fp_cumsum);
  CHECK_EQ(fp_cumsum.size(), num);

  // Compute precision.
  for (int i = 0; i < num; ++i) {
    prec->push_back(static_cast<float>(tp_cumsum[i]) /
                    (tp_cumsum[i] + fp_cumsum[i]));
  }

  // Compute recall.
  for (int i = 0; i < num; ++i) {
    CHECK_LE(tp_cumsum[i], num_pos);
    rec->push_back(static_cast<float>(tp_cumsum[i]) / num_pos);
  }

  if (ap_version == "11point") {
    // VOC2007 style for computing AP.
    vector<float> max_precs(11, 0.);
    int start_idx = num - 1;
    for (int j = 10; j >= 0; --j) {
      for (int i = start_idx; i >= 0 ; --i) {
        if ((*rec)[i] < j / 10.) {
          start_idx = i;
          if (j > 0) {
            max_precs[j-1] = max_precs[j];
          }
          break;
        } else {
          if (max_precs[j] < (*prec)[i]) {
            max_precs[j] = (*prec)[i];
          }
        }
      }
    }
    for (int j = 10; j >= 0; --j) {
      *ap += max_precs[j] / 11;
      temp->push_back(max_precs[j]); // save max_prec
    }
  } else if (ap_version == "MaxIntegral") {
    // VOC2012 or ILSVRC style for computing AP.
    float cur_rec = rec->back();
    float cur_prec = prec->back();
    for (int i = num - 2; i >= 0; --i) {
      cur_prec = std::max<float>((*prec)[i], cur_prec);
      if (fabs(cur_rec - (*rec)[i]) > eps) {
        *ap += cur_prec * fabs(cur_rec - (*rec)[i]);
      }
      cur_rec = (*rec)[i];
    }
    *ap += cur_rec * cur_prec;
  } else if (ap_version == "Integral") {
    // Natural integral.
    float prev_rec = 0.;
    for (int i = 0; i < num; ++i) {
      if (fabs((*rec)[i] - prev_rec) > eps) {
        *ap += (*prec)[i] * fabs((*rec)[i] - prev_rec);
      }
      prev_rec = (*rec)[i];
    }
  } else {
    LOG(FATAL) << "Unknown ap_version: " << ap_version;
  }
}


2. 修改ssd(caffe)代码来输出AP和绘制P-R曲线

2.1 修改代码输出AP

对于输出每一类的AP值，只要修改caffe中的配置文件即可，在ssd中修改的文件为： caffe/exampels/ssd/score_ssd_pascal.py中的 solver_param={}中的‘show_per_class_result’参数，该参数为True是，输出每一类的AP和所有类的mAP，当该参数为False时，只输出mAP。

2.2 修改代码绘制每一类的P-R曲线

需要修改的代码文件有： caffe/src/caffe/util/bbox_util.cpp 以及bbox_util.hpp 以及 solver.cpp 和caffe.proto 以及 caffe/exampels/ssd/score_ssd_pascal.py。

i)在bbox_util.cpp中修改的内容主要是，保存每一类在计算过程中的max_precision(11Point)。

      修改代码为(主要有两部分，一个是函数定义时：加入了vector<float>* temp, 另一个是在11Point模式下，加入了保存max_precision的代码， temp->bushback(max_precs[j]))：

void ComputeAP(const vector<pair<float, int> >& tp, const int num_pos,
               const vector<pair<float, int> >& fp, const string ap_version,
               vector<float>* prec, vector<float>* rec, float* ap, vector<float> *temp) {
  const float eps = 1e-6;
  CHECK_EQ(tp.size(), fp.size()) << "tp must have same size as fp.";
  const int num = tp.size();
  // Make sure that tp and fp have complement value.
  for (int i = 0; i < num; ++i) {
    CHECK_LE(fabs(tp[i].first - fp[i].first), eps);
    CHECK_EQ(tp[i].second, 1 - fp[i].second);
  }
  prec->clear();
  rec->clear();
  *ap = 0;
  if (tp.size() == 0 || num_pos == 0) {
    return;
  }

  // Compute cumsum of tp.
  vector<int> tp_cumsum;
  CumSum(tp, &tp_cumsum);
  CHECK_EQ(tp_cumsum.size(), num);

  // Compute cumsum of fp.
  vector<int> fp_cumsum;
  CumSum(fp, &fp_cumsum);
  CHECK_EQ(fp_cumsum.size(), num);

  // Compute precision.
  for (int i = 0; i < num; ++i) {
    prec->push_back(static_cast<float>(tp_cumsum[i]) /
                    (tp_cumsum[i] + fp_cumsum[i]));
  }

  // Compute recall.
  for (int i = 0; i < num; ++i) {
    CHECK_LE(tp_cumsum[i], num_pos);
    rec->push_back(static_cast<float>(tp_cumsum[i]) / num_pos);
  }

  if (ap_version == "11point") {
    // VOC2007 style for computing AP.
    vector<float> max_precs(11, 0.);
    int start_idx = num - 1;
    for (int j = 10; j >= 0; --j) {
      for (int i = start_idx; i >= 0 ; --i) {
        if ((*rec)[i] < j / 10.) {
          start_idx = i;
          if (j > 0) {
            max_precs[j-1] = max_precs[j];
          }
          break;
        } else {
          if (max_precs[j] < (*prec)[i]) {
            max_precs[j] = (*prec)[i];
          }
        }
      }
    }
    for (int j = 10; j >= 0; --j) {
      *ap += max_precs[j] / 11;
      temp->push_back(max_precs[j]); // save max_prec
    }
  } else if (ap_version == "MaxIntegral") {
    // VOC2012 or ILSVRC style for computing AP.
    float cur_rec = rec->back();
    float cur_prec = prec->back();
    for (int i = num - 2; i >= 0; --i) {
      cur_prec = std::max<float>((*prec)[i], cur_prec);
      if (fabs(cur_rec - (*rec)[i]) > eps) {
        *ap += cur_prec * fabs(cur_rec - (*rec)[i]);
      }
      cur_rec = (*rec)[i];
    }
    *ap += cur_rec * cur_prec;
  } else if (ap_version == "Integral") {
    // Natural integral.
    float prev_rec = 0.;
    for (int i = 0; i < num; ++i) {
      if (fabs((*rec)[i] - prev_rec) > eps) {
        *ap += (*prec)[i] * fabs((*rec)[i] - prev_rec);
      }
      prev_rec = (*rec)[i];
    }
  } else {
    LOG(FATAL) << "Unknown ap_version: " << ap_version;
  }
}


 

ii) 在bbox_util.hpp中修改的主要是ComputeAP函数的声明参数。

iii) 在solver.cpp 中声明的主要是：打印输出max_precison的情况

vector<float> prec, rec, p_r; // add p_r vector
      ComputeAP(label_true_pos, label_num_pos, label_false_pos,
                param_.ap_version(), &prec, &rec, &(APs[label]), &p_r); // add &p_r parameter
      mAP += APs[label];
      if (param_.show_per_class_result()) {
        LOG(INFO) << "class" << label << ": " << APs[label];
        if(param_.show_pr_value()){ //  add output MAX_Precision if given a Recall value
          for(int i=0; i < p_r.size(); i++){
              LOG(INFO)<<"for plot P-R for each class: "<<p_r[i];
           // LOG(INFO)<<"for plot P-R for each class Precision: "<<prec[i];  // add output line
           // LOG(INFO)<<"for plot P-R for each class Recall: "<<rec[i]; 
          }
        }
      }


iv)在caffe.proto 修改的是: 添加一个控制是否输出每一类的max_precision（11Point）的变量。

// If true, display pr value of per class
  optional bool show_pr_value = 45 [default = false];  // add line to show MAX_precision given a Recall value


v) 在caffe/examples/ssd/score_ssd_pascal.py中修改配置文件，选择是否输出 max_precision（11Point）

solver_param = {
    # Train parameters
    'base_lr': base_lr,
    'weight_decay': 0.0005,
    'lr_policy': "multistep",
    'stepvalue': [80000, 100000, 120000],
    'gamma': 0.1,
    'momentum': 0.9,
    'iter_size': iter_size,
    'max_iter': 0,
    'snapshot': 0,
    'display': 10,
    'average_loss': 10,
    'type': "SGD",
    'solver_mode': solver_mode,
    'device_id': device_id,
    'debug_info': False,
    'snapshot_after_train': False,
    # Test parameters
    'test_iter': [test_iter],
    'test_interval': 10000,
    'eval_type': "detection",
    'show_per_class_result': True,  ## whether output AP for each class
    'show_pr_value': True,    ## whether output max_precision for each class
    'ap_version': "11point",  ## the way of computing AP
    'test_initialization': True,
    }


2.3 绘制P-R曲线

如何在caffe/examples/ssd/score_ssd_pascal.py中绘制P-R曲线，请参考我的博客——python-matplotlib 绘制折线图（同时解决XShell远程访问Ubuntu使用matplotlib绘制图时，出现的问题）

 


There may be some mistakes in this blog. So, any suggestions and comments are welcome!


[Reference]

[1] ssd（caffe）代码：https://github.com/weiliu89/caffe/tree/ssd

[2] 修改输出AP的代码：https://blog.csdn.net/xunan003/article/details/79252162

[3] 11Point AP计算的理解：https://medium.com/@jonathan_hui/map-mean-average-precision-for-object-detection-45c121a31173

[4] 11Point AP计算的理解：https://github.com/Cartucho/mAP

[5] ssd(caffe)源码解读：https://blog.csdn.net/xunan003/article/details/79089280

[6] mAP计算的理解： http://forums.fast.ai/t/mean-average-precision-map/14345

Python基础教程 第5课 Python如何使用ASCII码输出内容
在编程的时候，我们输入的符号可以使用ASCII码的形式输入。ASCII码是美国信息交换标准码，最早只有127个字母被编码到计算机里面，也就是英文大小写字母，数字和一些符号，由这些组成的编码表被称为ASCII编码，如图1.1。
图1.1 ASCII编码表
下面我们来举几个例子理解一下。
比如我们通过在表中查询ASCII码，大写字母A的编码为65，小写字母的编码是97。我们想输出A和a，可以通过使用chr函数用ASCII码得到对应的字母输出。
我们首先启动PyCharm编译环境，新建一个Python文件，得到界面如图1.2
图1.2 新建一个Python文件
我们编写如下代码：
print("a") # 输出a
print(chr(97)) # 输出值为97的ASCII码
print("A") # 输出b
print(chr(65)) # 输出值为97的ASCII码
我们运行一下程序，可以得到输出结果为"a a A A"，如图1.3。
图1.3 输出结果
第一行代码输出为"a"，因为我们直接输出字母，肯定很好理解的，第二行代码中，我们使用chr函数，输出的是ASCII值为97的字符，也是"a"。第三行和第四行输出"A"也是一样的道理。
如果想输出ASCII码对应的其他字符也可以用这样的方式输出。下面我们来尝试一下输出ASCII码为123和125的的字符试试
编写如下代码
print(chr(123), end=" ") # 输出值为123的ASCII码
print(chr(125)) # 输出值为125的ASCII码
这里的end=" "是为了能够使字符能够输出到一行上，我们可以看一下Print函数的使用方法，如图1.4
图1.4 Print函数帮助
然后我们运行一下程序，可以看到结果输出了"{}"一对大括号，如图1.5
图1.5 输出 {}大括号
高手进阶：尝试使用ASCII码输出"I Love You ！"(嘻嘻嘻，好想找个女盆友，我来用ASCII码输出句小情话)
我自己写的代码如下：
print(chr(73), end="") # 输出I
print(chr(32), end="") # 输出1个空格
print(chr(76), end="") # 输出L
print(chr(111), end="") # 输出o
print(chr(118), end="") # 输出v
print(chr(101), end="") # 输出e
print(chr(32), end="") # 输出1个空格
print(chr(89), end="") # 输出Y
print(chr(111), end="") # 输出o
print(chr(117), end=" ") # 输出u和一个空格
print(chr(33), end="") # 输出!
嘻嘻嘻，这是我用的笨办法，每行代码只输出一个字符，输出结果如图1.6
图1.6 使用ASCII码输出“I Love You !"
以上就是Python如何使用ASCII码输出内容的笔记分享，我们下节课再见。

 
我想通过保存按钮将文本框中的文字输出到word文档中，开始运行的很好，但后来改动界面后不知怎么不行了。
同样的代码在word宏中也是有时可以运行，有时就进行不下去。
请大侠多指教！
程序界面和程序编辑界面分别如上！
代码如下：

Private Sub Command1_Click()

AddOut_Word
End Sub
Private Sub Command2_Click()
End
End Sub

Private Sub Command3_Click()
Text4.Text = Val(Text3.Text) * 3
Label1.Caption = "m3/h"

End Sub
Private Sub Form_Load()
Text1.Text = "酸浸矿浆"
Text2.Text = "2007-10-1"
Text3.Text = "10"
Text4.Text = ""
End Sub
Public Sub AddOut_Word()     '定义的一个调用过程

      Dim wdapp As Word.Application
      Dim wddoc As Word.Document
      '创建Word应用程序
      Set wdapp = CreateObject("Word.application")
      '在Word中添加一个新文挡
      
      With wdapp
       .Visible = True
       .Activate
      End With
      
      Biaoge
      
       Selection.TypeParagraph
    Selection.TypeText Text:="是"
    Selection.TypeParagraph
    Selection.TypeText Text:=" 大接访"
    Selection.TypeParagraph
    Selection.TypeText Text:="发给  答复"
    
    
    Selection.TypeParagraph
    
      Selection.TypeText Text:="试验时间: "
      Selection.TypeParagraph
      Selection.TypeText Text:="物料名称: "
     
      
    Set wdapp = Nothing
    Set wddoc = Nothing
End Sub
Public Sub Biaoge()
    Selection.TypeParagraph
    ActiveDocument.Tables.Add Range:=Selection.Range, NumRows:=2, NumColumns:= _
        3, DefaultTableBehavior:=wdWord9TableBehavior, AutoFitBehavior:= _
        wdAutoFitFixed
    With Selection.Tables(1)
        If .Style <> "网格型" Then
            .Style = "网格型"
        End If
        .ApplyStyleHeadingRows = True
        .ApplyStyleLastRow = True
        .ApplyStyleFirstColumn = True
        .ApplyStyleLastColumn = True
    End With
    Selection.TypeText Text:="物料固含量，g/L"
    Selection.MoveRight Unit:=wdCell
    Selection.TypeText Text:="泥饼量，kg/h"
    Selection.MoveRight Unit:=wdCell
    Selection.TypeText Text:="泥饼含水率，%"
    Selection.MoveDown Unit:=wdLine, Count:=1
    Selection.TypeText Text:=Text3.Text
    
End Sub