本文大纲

os模块是Python标准库中一个重要的模块，里面提供了对目录和文件的一般常用操作。而Python另外一个标准库——shutil库，它作为os模块的补充，提供了复制、移动、删除、压缩、解压等操作，这些 os 模块中一般是没有提供的。但是需要注意的是：shutil 模块对压缩包的处理是调用 ZipFile 和 TarFile这两个模块来进行的。

知识串讲

本文所使用的素材，都是基于以下2个文件夹，其中一个文件夹为空。

1）模块导入

import shutil

2）复制文件

• 函数：shutil.copy(src,dst)
• 含义：复制文件；
• 参数：src表示源文件，dst表示目标文件夹；
• 注意：当移动到一个不存在的“目标文件夹”，系统会将这个不存在的“目标文件夹”识别为新的文件夹，而不会报错；

# 1.将a表的“data.txt”移动到b表
src = r"C:\Users\黄伟\Desktop\publish\os模块\test_shutil_a\data.txt"
dst = r"C:\Users\黄伟\Desktop\publish\os模块\test_shutil_b"

shutil.copy(src,dst)
------------------------------------------------------------
# 2.将a表的“data.txt”移动到b表，并重新命名为“new_data.txt”
src = r"C:\Users\黄伟\Desktop\publish\os模块\test_shutil_a\data.txt"
dst = r"C:\Users\黄伟\Desktop\publish\os模块\test_shutil_b\new_data.txt"

shutil.copy(src,dst)
------------------------------------------------------------
# 3.将a表的“data.txt”移动到“不存在”的文件夹
src = r"C:\Users\黄伟\Desktop\publish\os模块\test_shutil_a\data.txt"
dst = r"C:\Users\黄伟\Desktop\publish\os模块\test_shutil_c"

shutil.copy(src,dst)
"""
注意：对于情况3，系统会默认将“test_shutil_c”识别为文件名，而不是按照我们认为的，移动到一个新的不存在的文件夹。
"""

结果如下：

3）复制文件夹

• 函数：shutil.copytree(src,dst)
• 含义：复制文件夹；
• 参数：src表示源文件夹，dst表示目标文件夹；
• 注意：这里只能是移动到一个空文件夹，而不能是包含其他文件的非空文件夹，否则会报错PermissionError；

① 如果目标文件夹中存在其他文件，会报错；

# 将a文件夹移动到b文件夹，由于前面的操作，此时b文件夹中已经有其他文件
src = r"C:\Users\黄伟\Desktop\publish\os模块\test_shutil_a"
dst = r"C:\Users\黄伟\Desktop\publish\os模块\test_shutil_b"

shutil.copytree(src,dst)

结果如下：

② 如果指定任意一个目标文件夹，则会自动创建；

# c文件夹原本是不存在的，我们使用了下方的代码，会自动创建该文件夹
src = r"C:\Users\黄伟\Desktop\publish\os模块\test_shutil_a"
dst = r"C:\Users\黄伟\Desktop\publish\os模块\test_shutil_c"

shutil.copytree(src,dst)

结果如下：

4）移动文件或文件夹

• 函数：shutil.move(src,dst)
• 含义：移动文件/文件夹；
  – 参数：src表示源文件/文件夹，dst表示目标文件夹；
• 注意：文件/文件夹一旦被移动了，原来位置的文件/文件夹就没了。目标文件夹不存在时，会报错；

# 将当前工作目录下的“a.xlsx”文件，移动到a文件夹下
dst = r"C:\Users\黄伟\Desktop\publish\os模块\test_shutil_a"
shutil.move("a.xlsx",dst)
----------------------------------------------------------------
# 将a文件夹下的“a.xlsx”文件，移动到b文件夹中，并重新命名为“aa.xlsx”
src = r"C:/Users/黄伟/Desktop/publish/os模块/test_shutil_a\a.xlsx"
dst = r"C:\Users\黄伟\Desktop\publish\os模块\test_shutil_b\aa.xlsx"
shutil.move(src,dst)

结果如下：

注意：移动文件夹操作类似，我这里就不赘述了，自行下去学习。

5）删除文件夹(慎用)

• 函数：shutil.rmtree(src)
• 含义：删除文件夹；
• 参数：src表示源文件夹；
• 注意：区别这里和os模块中remove()、rmdir()的用法，remove()方法只能删除某个文件，mdir()只能删除某个空文件夹。但是shutil模块中的rmtree()可以递归彻底删除非空文件夹；

# 将c文件夹彻底删除
src = r"C:\Users\黄伟\Desktop\publish\os模块\test_shutil_c"
shutil.rmtree(src)

结果如下：

6）创建和解压压缩包

• zipobj.write()：创建一个压缩包；
• zipobj.namelist()：读取压缩包中的文件信息；
• zipobj.extract()：将压缩包中的单个文件，解压出来；
• zipobj.extractall()：将压缩包中所有文件，解压出来；
• shutil 模块对压缩包的处理是调用 ZipFile 和 TarFile这两个模块来进行的，因此需要导入这两个模块；
• 注意：这里所说的压缩包，指的是“.zip”格式的压缩包；

① 创建一个压缩包

import zipfile
import os
file_list = os.listdir(os.getcwd())
# 将上述所有文件，进行打包，使用“w”
with zipfile.ZipFile(r"我创建的压缩包.zip", "w") as zipobj:
    for file in file_list:
        zipobj.write(file)

结果如下：

② 读取压缩包中的文件信息

import zipfile

with zipfile.ZipFile("我创建的压缩包.zip", "r") as zipobj:
    print(zipobj.namelist())

结果如下：

③ 将压缩包中的单个文件，解压出来

• 注意：目标文件夹不存在，会自动创建；

import zipfile
# 将压缩包中的“test.ipynb”文件，单独解压到a文件夹下
dst = r"C:\Users\黄伟\Desktop\publish\os模块\test_shutil_a"
with zipfile.ZipFile("我创建的压缩包.zip", "r") as zipobj:
    zipobj.extract("test.ipynb",dst)

结果如下：

④ 将压缩包中所有文件，解压出来；

• 注意：目标文件夹不存在，会自动创建；

import zipfile
# 将压缩包中的所有文件，解压到d文件夹下
dst = r"C:\Users\黄伟\Desktop\publish\os模块\test_shutil_d"
with zipfile.ZipFile("我创建的压缩包.zip", "r") as zipobj:
    zipobj.extractall(dst)

结果如下：

1. 引言

最近在研究前端框架，但发现好多JavaScript知识不是很了解，很是苦恼，下面就来研究一下JavaScript的模块化，先理解几个概念和模块化的进化过程。

2. 模块化

2.1 什么是模块？

模块就是将一个复杂的程序依据一定的规则（规范）封装成几个块（文件）， 并进行组合在一起，块的内部数据和实现是私有的， 只是向外部暴露一些接口（方法）与外部其它模块通信。

一个模块的组成由两部分组成： 数据（内部的属性）、操作数据的行为（内部的函数）

2.2 模块化的进化过程

2.2.1 全局function模式

​ 模块一：module1.js

// 数据
let data = 'module1'
// 操作数据的函数
function foo() {
  console.log(`foo() ${data}`)
}
function bar() {
  console.log(`bar() ${data}`)
}

模块二：module2.js

let data2 = 'module2'
function foo() {  //与另一个模块中的函数冲突了
	console.log(`foo() ${data2}`)
}

页面引入：test.html

<script type="text/javascript" src="module1.js"></script>
<script type="text/javascript" src="module2.js"></script>
<script type="text/javascript">
  let data = "修改后的数据"
  foo() // 冲突
  bar()
</script>

说明：全局函数模式是将不同的功能函数封装成不同的全局函数，这样会有一些问题， 比如上面两个模块中都有foo函数，如果同时引入，将不知道调用的是哪一个，很容易引起命名冲突，污染全局命名空间，导致数据不安全。（上面的两个模块中的函数会成为window对象中的函数）

2.2.2 namespace模式

模块一：module1.js

let myModule1 = {
  data: 'module1',
  foo() {
    console.log(`foo() ${this.data}`)
  },
  bar() {
    console.log(`bar() ${this.data}`)
  }
}

模块二：module2.js

let myModule2 = {
  data: 'module2',
  foo() {
    console.log(`foo() ${this.data}`)
  },
  bar() {
    console.log(`bar() ${this.data}`)
  }
}

页面引入：test.html

<script type="text/javascript" src="module1.js"></script>
<script type="text/javascript" src="module2.js"></script>
<script type="text/javascript">
  // module.js模块
  myModule1.foo()
  myModule1.bar()
  // module2.js模块
  myModule2.foo()
  myModule2.bar()
  
  myModule1.data = 'other data' //能直接修改模块内部的数据
  myModule1.foo()
</script>

说明：namespace模式就是简单对象封装，它虽然解决了命名冲突的问题，减少了全局变量，但依然存在问题，我们可以在外部可以直接修改模块内部的数据，导致数据不安全。

2.2.3 IIFE模式/增强

模块：module1.js

(function (window) {
  //数据
  let data = 'module1'
  //操作数据的函数
  function foo() { //用于暴露有函数
    console.log(`foo() ${data}`)
  }
  function bar() {//用于暴露有函数
    console.log(`bar() ${data}`)
    otherFun() //内部调用
  }
  function otherFun() { //内部私有的函数
    console.log('otherFun()')
  }
  // 暴露foo,bar，并没有暴露otherFun,所以外界无法访问
  window.myModule = {foo, bar}
})(window)

页面引入：test.html

<script type="text/javascript" src="module1.js"></script>
<script type="text/javascript">
  myModule.foo()
  myModule.bar()
  //myModule.otherFun()  //myModule.otherFun is not a function，没有暴露
  console.log(myModule.data) //undefined 不能访问模块内部数据
  myModule.data = 'xxxx' //不是修改的模块内部的data
  myModule.foo() //没有改变
</script>

说明：IIFE : immediately-invoked function expression(立即调用函数表达式)，就是匿名函数自调用(闭包)，它通过将数据和行为封装到一个函数内部, 通过给window添加属性来向外暴露接口，它的作用是，数据是私有的, 外部只能通过暴露的方法操作。但此时有个问题: 如果当前这个模块依赖另一个模块怎么办?

下面拿jQuery举例，把jQuery引入到项目中
模块：module1.js

  (function (window, $) {
      //数据
      let data = 'module1'
      //操作数据的函数
      function foo() { //用于暴露有函数
        console.log(`foo() ${data}`)
        $('body').css('background', 'red')
      }
      function bar() {//用于暴露有函数
        console.log(`bar() ${data}`)
        otherFun() //内部调用
      }
      function otherFun() { //内部私有的函数
        console.log('otherFun()')
      }
      //暴露行为
      window.myModule = {foo, bar}
    })(window, jQuery)

页面引入：test.html

<script type="text/javascript" src="jquery-1.10.1.js"></script>
<script type="text/javascript" src="module1.js"></script>
<script type="text/javascript">
  myModule.foo()
</script>

引入依赖，是IIFE模式的增强，也是现代模块实现的基石。

3. 模块化规范

模块分的规范有如下四种：CommonJS、AMD、CMD、ES6，下面逐一介绍一下。

3.1 CommonJS

遵循CommonJS规范的有：Node.js（服务器端）、 Browserify （浏览器端），Browserify 也称为js的打包工具 。 暴露的本质就是暴露exports对象

基本语法：定义暴露模块 : exports

exports.xxx = value
module.exports = value

引入模块 : require

var module = require('模块名') // 引入第三方模块
var module = require('模块相对路径')

说明

• 一个文件就是一个模块，require方法用来加载模块，该方法读取一个文件并执行，最后返回文件内部的module.exports对象
• require是默认读取.js文件的，所以require(模块名)可以不写后缀
• module.exports属性表示当前模块对外输出的接口，其他文件加载该模块，实际上就是读取module.exports变量；为了方便也可以用exports，exports指向module.exports；即exports = module.exports = {}，exports.xxx相当于在导出的对象上添加属性，该属性对调用模块可见
• exports = 相当于给exports重新赋值，这样就切断了和module.exports的关联，调用模块就不能访问exports的对象及其属性；

3.2 AMD （浏览器端）

AMD是requireJS倡导的一种模块化规范，推崇依赖前置；在requireJS中模块是通过define来进行定义的，如果模块之间相互依赖，需要先将依赖模块导入进来，待导入完毕之后，在通过回掉函数的方式执行后面的代码，有效的解决了模块依赖的问题。

定义暴露模块

define([依赖模块名], function(){return 模块对象})

引入模块

require(['模块1', '模块2', '模块3'], function(m1, m2){//使用模块对象})

配置:

require.config({
	// 基本路径
    baseUrl: "js/lib",
     // 标识名称与路径的映射
    paths: {
     "jquery": "jquery.min",
     "underscore": "underscore.min",
     "backbone": "backbone.min"
　 	},
　 	//非AMD的模块
    shim: {
       'underscore':{
            exports: '_'
　　		},
	　　'backbone': {
	　　　　deps: ['underscore', 'jquery'],
	　　　　exports: 'Backbone'
	　　}
　	}
});

3.3 CMD （浏览器端）

CMD则是seaJS倡导的一种解决模块之间相互依赖规范，推崇依赖就近，在seaJS中一个脚本文件就是一个模块，所有的模块代码写在define的回调函数中，传递三个参数require、exports、module，通过使用 module.exports（exports） 对象向外暴露。

require 函数加载模块的时候，会自动拿到模块内部的 module.exports 对象。定义暴露模块:

define(function (require, exports, module) {
	// 通过require引入依赖模块
    var moduleA = require('add.js') // 等待add.js下载、执行完
    console.log(moduleA.add(10,20))
})

// add.js
define(function (require, exports, module) {
  function add(a, b){
    return a+b;
  }
  // 通过module/exports来暴露模块
  module.exports.add = add;
})

• AMD和CMD最大的区别是对依赖模块的执行时机处理不同，而不是加载的时机或者方式不同，二者皆为异步加载模块
• AMD依赖前置，js可以方便知道依赖模块是谁，立即加载；而CMD就近依赖，需要使用把模块变为字符串解析一遍才知道依赖了那些模块

3. 4 ES6

ES6在语言标准上面实现了模块功能。设计思想是尽量的静态化，使得编译时就能确定模块的依赖关系，以及输入输出变量，CommonJS以及AMD都只能在运行时确定，ES6的模块并不是对象，而是通过export显示指定输出的代码，再通过import命令导入。

可以使用ES6的模块暴露和引入来实现模块化编程，ES6暴露模块的方式有三种：分别暴露、统一暴露（前两者也称为常规暴露）和默认暴露。

3.4.1 分别暴露

模块一：module1.js

// 分别暴露：也叫多行暴露，每个方法逐一暴露，这种方式在引入时需要用对象来引入
export function foo() {
    console.log('foo() moudle1');
}
export function bar() {
    console.log('bar() moudle1')
}

3.4.2 统一暴露

模块二：module2.js

function fun1() {
    console.log('fun1() module2')
}
function fun2() {
    console.log('fun2() module2')
}
// 统一暴露： 暴露的是一个对象，引入时也必须是个对象
export {foo,bar} 

需要注意的是：以上两种向外暴露方式在主文件引入时必须使用对象的解构赋值引用，不能使用变量接收的方式来映入（注意和默认暴露的区别）

主模块：main.js

import {foo,bar} from '.js/src/module1.js'
import {fun1,fun2} from './js/src/module2.js'

3.4.3 默认暴露

export default {
    foo() {
        console.log('默认暴露方式')
    },
    bar() {
        console.log('默认暴露')
    }
}

默认暴露的方式只允许有一个: export default {}且在主模块引入时可以使用定义变量来接收的方式！

// 引入模块3
import module3 from '.js/src/module3.js'
// 使用模块
module3.foo()
module3.bar()

注意：在使用`ES6`时，会出现一些问题，现在由于并不是所有浏览器都能直接识别`ES6`模块化的语法，所有在不能识别`ES6`语法的浏览器上，就不能执行`ES6`代码，这时就需要用到`Babel`，将`ES6`语法转化为`ES5`(使用了`CommonJS`) ，但此时浏览器还不能直接执行，还需要再使用`Browserify`对`ES5`语法的代码进行打包处理，最后得到的文件，浏览器可以运行。

       Matlab:matrix laboratory，一种以矩阵为来处理数据的的计算软件，应用范围十分广泛，该产品有若干模块组成，Simulink是其中一个，利用图形化的工具来进行建模与仿真。Simulink是Matlab软件的扩展，它是实现动态系统建模和仿真的一个软件包，它与MATLAB语言的主要区别在于，其与用户交互接口是基于Windows的模型化图形输入，其结果是使得用户可以把更多的精力投入到系统模型的构建，而非语言的编程上。

       Simulink是基于matlab的框图设计环境，可以用来对各种动态系统进行建模、分析和仿真，谓模型化图形输入是指Simulink提供了一些按功能分类的基本的系统模块，用户只需要知道这些模块的输入输出及模块的功能，而不必考察模块内部是如何实现的，通过对这些基本模块的调用，再将它们连接起来就可以构成所需要的系统模型（以.mdl文件进行存取），进而进行仿真与分析。Simulink 中的“Simu”一词表示可用于计算机仿真，而“Link”一词表示它能进行系统连接，即把一系列模块连接起来，构成复杂的系统模型。它的应用领域十分广泛，任何能用数学模型来描述的系统都可以在simulink中进行仿真分析，如：空气动力学、导航制导、通讯、电子、机械、热力学等诸多领域，这些系统从数学角度来描述多涉及连续、离散、非线性、时变、条件执行、多速率混合等用解析方法难以求解的系统，他们都可以通过simulink进行建模与仿真，从而指导系统的分析与设计。

Simulink主要有以下特点：

在库模块浏览器中单击Simulink前面的“+”号， 就能够看到Simulink的模块库，下面主要就主要的模块进行介绍：

一、常用模块库(Commonly Used Blocks)

1、In模块

此模块为信号的输入端口，当它存放于子系统模型中时，为子系统模型增加一个输入端口，是连接上层模型与当前层次模型的接口，将父层模型的信号传递到当前层次模型中来。In模块也可以存在于模型最顶层，这时由于没有父层，不用为父层提供信号接口，其功能类似于一个默认输出值为0的常数模块，另外，结合Configuration Parameter对话框中的数据导入功能，还可以预设In模块的输出值。

2、Out模块

此模块为信号的输出端口，当它存放于系统模型中时，为子系统模型增加一个输出端口，是连接上层模型与当前层次模型的桥梁，将当前层次模型的信号传递到父层模型中去。Out模块也可以存在于模型最顶层，这时由于没有父层，不传递到父层，也不显示出波形，仅作为一个默认输出，必要时可以设置将接收的数据存储到工作空间的变量中。

3、常数模块

常数模块在仿真过程中通常输出恒定的数值。常数模块不仅支持scalar数据作为参数输入，也支持向量、矩阵等多维数据的信号输出。

4、波形显示模块

是模型中的示波器，能够显示模型中的信号波形，方便观察和保留。该模块默认有一个输入，可以连接任何类型的实数信号线（不支持负数）。

5、四则运算模块

Simulink Library Browser 提供的四则运算法则模块包括Sum、Product和Gain模块，分别能实现多个数的加减、乘除和单个数的增益运算。

6、Divide模块

两个或多个信号的乘除法运算

7、Gain模块

Gain模块是具有一个输入一个输出的增益模块，模块图标是一个三角形。

8、延时模块

Delay模块是延时模块，具有一个输入端口和一个输出端口。输入信号为标量、向量或矩阵。Unit Delay模块是Delay模块模块的一个特例，即只延时一个采样时间。其参数对话框比较简单，不需要设置Delay Length，不需要考虑缓冲区使用环形或线性区域，没有复位功能。

9、关系操作模块

Relational Operator 模块集合了各种比较功能于一体，图标可根据用户指定的比较关系显示为一个或两个输入端口。

10、逻辑运算模块

Logical Operator 模块集合了常用逻辑操作功能于一体，根据用户选择的逻辑关系不同会显示为一个或多个输入端口，输出端口总是一个。

11、Switch模块

Switch模块是一个开关选择模块，可根据判断条件选择多个输入端口中的某个进行输出。

12、积分模块

积分模块是Simulink中一个常用的典型连续模块，是对输入信号的连续时间积分。

13、限幅模块

默认包含一个输入端口和一个输出端口，模块图标上绘制着上下限受到约束保持上下限值的图像，上限值一定要大于或等于下限值，否则在单击参数对话框的OK或Apply时会报错。

14、接地模块

Ground模块是将输入端口接地的模块，避免仿真时某些模块出现输入端口未连接的警告，有一个输出，输出值为0.

15、终止模块

Terminator模块就是用来接收未使用的输出信号的，仅有一个输入端口。可以接受Simulink支持的数据类型：实数、复数以及固定点数据。

16、信号合并与分解模块

Simulink的信号可以通过信号合并模块Mux组成多维信号，Mux模块是一个虚拟模块，虽然视觉上将多个信号合并成一个信号，但是实际上并没有改变其内部数据结构，只是视觉上看起来线的条数减少并可以统一管理。Demux模块能将多维信号分解为单维或维数较少的多维信号。

17、总线创建与总线选择模块

Bus Creator模块将输入的一系列信号合并为一个总线。该模块可设置为虚拟模块，也可设置为非虚拟模块。

Bus Select模块可从总线中选择出一个或者一组成员。

18、向量连接模块

Vector Concatenate模块是将多个输入信号组合成一个非虚拟输出信号，这个输出信号的各个元素存储在内存中的连续单元。

19、数据类型转换模块

Simulink支持多种数据类型，包括浮点数。固定点数及枚举型数据，当前一个模块的输出信号于后面连接的模块的输入端口支持的数据类型不一致时，Simulink会报出错误。这时可以使用数据类型转换模块Data Type Conversion进行数据类型转换以使模型能够顺利通过仿真或生存代码。

20、子系统模块

子系统（subsystem）就是将一些基本模块及其信号连线组合成一个大的模块，屏蔽内部结构，仅仅将输入输出个数表现在外的层次性划分。

二、连续模块库(Continuous)

在连续模块(Continuous)库中包括了常见的连续模块，
1. 积分模块(Integrator)：
功能： 对输入变量进行积分。 说明：模块的输入可以是标量， 也可以是矢量；输入信号的维数必须与输入信号保持一致。

2. 微分模块(Derivative)
功能： 通过计算差分∆u/ ∆t近似计算输入变量的微分。

3. 线性状态空间模块(State-Space)
功能： 用于实现以下数学方程描述的系统

4. 传递函数模块(Transfer Fcn)
功能： 用执行一个线性传递函数。

5. 零极点传递函数模块(Zero-Pole)
功能： 用于建立一个预先指定的零点、极点，并用延迟算子s表示的连续。

6．存储器模块(Memory)
功能： 保持输出前一步的输入值。

7．传输延迟模块(Transport Delay)
功能： 用于将输入端的信号延迟指定的时间后再传输给输出信号。

8．可变传输延迟模块(Variable Transport Delay)
功能： 用于将输入端的信号进行可变时间的延迟。

三、离散模块库(Discrete)

离散模块库(Discrete)主要用于建立离散采样的系统模型

1．零阶保持器模块(Zero-Order-Hold)
功能： 在一个步长内将输出的值保持在同一个值上。

2．单位延迟模块(Unit Delay)
功能： 将输入信号作单位延迟，并且保持一个采样周期相当于时间算子z-1 。

3． 离散时间积分模块(Discrete Time Integrator)
功能： 在构造完全离散的系统时， 代替连续积分的功能。 使用的积分方法有：向前欧拉法、 向后欧拉法、 梯形法。

4．离散状态空间模块(Discrete State Space)
功能： 用于实现如下数学方程描述的系统：

5．离散滤波器模块(Discrete Filter)
功能： 用于实现无限脉冲响应(IIR)和有限脉冲响应(FIR)的数字滤波器。

6．离散传递函数模块(Discrete Transfer Fcn)
功能： 用于执行一个离散传递函数。

7．离散零极点传递函数模块(Discrete Zero-Pole)
功能： 用于建立一个预先指定的零点、极点，并用延迟算子z-1表示的离散系统。

8．一阶保持器模块(First Order Hold)
功能：在一定时间间隔内保持一阶采样。

四、函数与表格模块库(Function & Table)
函数与表格模块库(Function & Table)主要实现各种一维、 二维或者更高维函数的
查表， 另外用户还可以根据自己需要创建更复杂的函数。

1. 一维查表模块(Look-Up Table)
一维查表模块(Look-Up Table)实现对单路输入信号的查表和线性插值。

2． 二维查表模块(Look-Up Table 2-D)
功能： 根据给定的二维平面网格上的高度值， 把输入的两个变量经过查表、 插值，计算出模块的输出值， 并返回这个值。
说明：对二维输入信号进行分段线性变换。

3． 自定义函数模块(Fcn)
功能： 用于将输入信号进行指定的函数运算， 最后计算出模块的输出值。
说明：输入的数学表达式应符合C语言编程规范；与MATLAB中的表达式有所不同， 不能完成矩阵运算。

4． MATLAB函数模块(MATLAB Fcn)
功能： 对输入信号进行MATLAB函数及表达式的处理。
说明：模块为单输入模块；能够完成矩阵运算。
注意：从运算速度角度， Math function模块要比Fcn模块慢。 当需要提高速度时，可以考虑采用Fcn 或者S函数模块。

5． S-函数模块(S-Function)
功能： 按照Simulink标准， 编写用户自己的Simulink函数。 它能够将MATLAB语句。

五、数学模块库(Math)
数学模块库(Math)包括多个数学运算模块

1. 求和模块(Sum)
功能： 求和模块(Sum)用于对多路输入信号进行求和运算， 并输出结果。

2. 乘法模块(Product)
功能： 乘法模块(Product)用于实现对多路输入的乘积、 商、 矩阵乘法或者模块的转置等。

3. 矢量的点乘模块(Dot Product)
功能： 矢量的点乘模块(Dot Product)用于实现输入信号的点积运算。

4. 增益模块(Gain)
功能： 增益模块(Gain)的作用是把输入信号乘以一个指定的增益因子， 使输入产生增益。

5. 常用数学函数模块(Math Function)
功能： 用于执行多个通用数学函数，其中包含exp、 log、 log10、 square、 sqrt、 pow、
reciprocal、 hypot、 rem、 mod等。

6. 三角函数模块(Trigonometric Function)
功能： 用于对输入信号进行三角函数运算，共有10种三角函数供选择。

7. 特殊数学模块
特殊数学模块中包括求最大最小值模块(MinMax)、 取绝对值模块(Abs)、 符号函数模块(Sign)、 取整数函数模块(Rounding Function)等。

8. 数字逻辑函数模块
数字逻辑函数模块包括复合逻辑模块(Combinational Logic)、 逻辑运算符模块(Logical Operator)、 位逻辑运算符模块(Bitwise Logical Operator)等。

9. 关系运算模块(Relational Operator)
关系符号包括： ==(等于)、 ≠(不等于)、 <(小于)、 <=(小于等于)、 >(大于)、 >=(大于等于)等。

10. 复数运算模块
复数运算模块包括计算复数的模与幅角(Complex to Magnitude-Angle)、 由模和幅角计算复数(Magnitude-Angle to Complex)、 提取复数实部与虚部模块(Complex to Real and Image)、 由复数实部和虚部计算复数(Real and Image to Complex)。

六、非线性模块(Nonlinear)
非线性模块(Nonlinear)中包括一些常用的非线性模块

1. 比率限幅模块(Rate Limiter)
功能： 用于限制输入信号的一阶导数， 使得信号的变化率不超过规定的限制值。

2． 饱和度模块(Saturation)
功能： 用于设置输入信号的上下饱和度， 即上下限的值， 来约束输出值。

3． 量化模块(Quantizer)
功能： 用于把输入信号由平滑状态变成台阶状态。

4． 死区输出模块(Dead Zone)
功能： 在规定的区内没有输出值。

5． 继电模块(Relay)
功能： 继电模块(Relay)用于实现在两个不同常数值之间进行切换。

6． 选择开关模块(Switch)
功能： 根据设置的门限来确定系统的输出。

七、信号与系统模块库(signals &Systems)

1. Bus 信号选择模块(Bus Selector)
功能： 用于得到从Mux模块或其它模块引入的Bus信号。

2. 混路器模块(Mux)
功能： 把多路信号组成一个矢量信号或者Bus信号。

3.分路器模块(Demux)
功能： 把混路器组成的信号按照原来的构成方法分解成多路信号。

4. 信号合成模块(Merge)
功能： 把多路信号进行合成一个单一的信号。

5. 接收/传输信号模块(From/Goto)
功能： 接收/传输信号模块(From/Goto)常常配合使用， From模块用于从一个Goto模块中接收一个输入信号， Goto模块用于把输入信号传递给From模块。

6． 初始值设定模块(IC)
功能： 初始值设定模块(IC)用于设定与输出端口连接的模块的初始值。

八、信号输出模块(Sinks)
1. 示波器模块(Scope)
功能： 显示在仿真过程中产生的输出信号， 用于在示波器中显示输入信号与仿真时间的关系曲线， 仿真时间为x轴。

2. 二维信号显示模块(XY Graph)
功能： 在MATLAB的图形窗口中显示一个二维信号图， 并将两路信号分别作为示波器坐标的x轴与y 轴， 同时把它们之间的关系图形显示出来。

3. 显示模块(Display)
功能： 按照一定的格式显示输入信号的值。 可供选择的输出格式包括： short、 long、short_e、 long_e、 bank等。

4. 输出到文件模块(To File)
功能： 按照矩阵的形式把输入信号保存到一个指定的MAT文件。 第一行为仿真时间，余下的行则是输入数据， 一个数据点是输入矢量的一个分量。

5. 输出到工作空间模块(To Workspace)
功能： 把信号保存到MATLAB的当前工作空间， 是另一种输出方式。

6. 终止信号模块(Terminator)
功能： 中断一个未连接的信号输出端口。

7. 结束仿真模块(Stop simulation)
功能： 停止仿真过程。 当输入为非零时， 停止系统仿真。

九、信号源模块库(Sources)

该库包含了可向仿真模型提供信号的模块。它没有输入口，但至少有一个输出口。

1． 输入常数模块(Constant)
功能： 产生一个常数。 该常数可以是实数， 也可以是复数。

2． 信号源发生器模块(Signal Generator)
功能： 产生不同的信号， 其中包括：正弦波、 方波、 锯齿波信号。

3． 从文件读取信号模块(From File)
功能： 从一个MAT文件中读取信号， 读取的信号为一个矩阵， 其矩阵的格式与To File模块中介绍的矩阵格式相同。 如果矩阵在同一采样时间有两个或者更多的列， 则数据点的输出应该是首次出现的列。

4． 从工作空间读取信号模块(From Workspace)
功能： 从MATLAB工作空间读取信号作为当前的输入信号。

5． 随机数模块(Random Number)
功能： 产生正态分布的随机数， 默认的随机数是期望为0， 方差为1的标准正态分布量。

6． 带宽限制白噪声模块(Band Limited White Noise)
功能： 实现对连续或者混杂系统的白噪声输入。

十． 其它模块
除以上介绍的常用模块外， 还包括其模块。 各模块功能可通过以下方法查看： 先进入Simulink工作窗口， 在菜单中执行Help/Simulink Help命令， 这时就会弹出Help界面。然后用鼠标展开 Using Simulink\Block Reference\Simulink BlockLibraries就可以看到Simulink的所有模块。 查看相应的模块的使用方法和说明信息即可。

十一、仿真模型的建立与模块参数与属性的设置
1. 仿真模块的建立

首先启动Simulink命令， 建立一个空的模块窗口“untitled” ，然后利用Simulink提供的模块库，在 此 窗 口 中 创 建 自 己 需 要 的Simulink模型。
具体方法： 在模块库浏览器中找到所需模块， 选中该模块后右击鼠标， 把它加入到一个模型窗口
中即可完成模块的建立。

2、模块参数与属性的设置
方法： 在所建立的模型窗口中， 选中相应的模块， 单击右击鼠标， 在弹出的快捷菜单中单击“Block parameters”选项， 即可打开该模块的参数设置对话框。 右击 鼠 标 ， 在 弹 出 的 快 捷 菜 单 中 单 击“Block Properties”选项， 即可打开该模块的属性设置对话框。

3、模块的连接

一般情况下， 每个模块都有一个或者多个输入口或者输出口。 输入口通常是模块
的左边的“>”符号；输出口是右边的“>”符号。模块的连接方法： 把鼠标指针放到模块的输出口， 这时， 鼠标指针将变为“+”十字形；然后， 拖运鼠标至其它模块的输入口， 这时信号线就变成了带有方向箭头的线段。 此时， 说明这两个模块的连接成功， 否则需要重新进行连接。

4.运行仿真
在运行仿真之前， 首先保存已设置和连接的模型， 然后就可以运行仿真。

5、Simulink仿真注意与技巧
(1)Simulink的数据类型由于Simulink在仿真过程中， 始终都要检查模型的类型安全性。 模型的类
型安全性是指从该模型产生的代码不出现上溢或者下溢现象， 当产生溢出现象时， 系统将出错误。 查看模块的数据类型的方法是：在模型窗口的菜单中执行Format/Port Data Types命令， 这样每个模块支持的数据类型就显示出来了。 要取消数据类型的查看方式， 单击 Port Data Types去掉其前面的勾号即可。

(2) 数据的传输
在仿真过程中， Simulink首先查看有没有特别设置的信号的数据类型， 以及检验信号的输入和输出端口的数据类型是否产生冲突。 如果有冲突， Simulink将停止仿真，并给出一个出错提示对话框， 在此对话框中将显示出错的信号以及端口， 并把信号的路径以高亮显示。 遇到该情形， 必须改变数据类型以适应模块的需要。
(3)提高仿真速度
Simulink仿真过程， 仿真的性能受诸多因素的影响， 包括模型的设计和仿真参数的选择等。 对于大多数问题， 使用Simulink系统默认的解法和仿真参数值就能够比较好地解决。 因素及解决方法：
(1)仿真的时间步长太小。针对这种情况可以把最大仿真步长参数设置为默认值auto。
(2)仿真的时间过长。可酌情减小仿真的时间。
(3)选择了错误的解法。针对这种情况可以通过改变解法器来解决。
(4)仿真的精度要求过高。仿真时，如果绝对误差限度太小，则会使仿真在接近零的状态附近耗费过多时间。通常，相对误差限为0.1%就已经足够了。
(5)模型包含一个外部存储块。尽量使用内置存储模块。

(4)改善仿真精度
检验仿真精度的方法是：通过修改仿真的相对误差限和绝对误差限， 并在一个合适的时间跨度反复运行仿真， 对比仿真结果有无大的变化， 如果变化不大， 表示解是收敛的。 说明仿真的精度是有效的， 结果是稳定的。
如果仿真结果不稳定， 其原因可参是系统本身不稳定或仿真解法不适合。 如果仿
真的结果不精确， 其原因很可能是：
(1)模型有取值接近零的状态。 如果绝对误差过大， 会使仿真在接近零区域运行的仿真时间太小。 解决的办法是修改绝对误差参数或者修改初始的状态。
(2)如果改变绝对误差限还不能达到预期的误差限， 则修改相对误差限， 使可接受的误差降低， 并减小仿真的步长。