diff --git a/Lab01.ipynb b/Lab01.ipynb
index 3392378..6f9edfd 100644
--- a/Lab01.ipynb
+++ b/Lab01.ipynb
@@ -1,21 +1,15 @@
 {
  "cells": [
   {
-   "cell_type": "raw",
-   "metadata": {},
-   "source": [
-    "实践1 python初印象\n",
-    "学习目标\n",
-    "1.熟悉Jupyter lab交互开发环境\n",
-    "2.掌握Python 语句的编写，运行和修改\n",
-    "3.阅读Python微程序，尝试模仿改写程序"
-   ]
-  },
-  {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# 实践1 初识python程序"
+    "# 实践1 python初印象\n",
+    "\n",
+    "##  学习目标\n",
+    "1. 熟悉Jupyter lab交互开发环境\n",
+    "2. 掌握Python 语句的编写，运行和修改\n",
+    "3. 阅读Python微程序，尝试模仿改写程序"
    ]
   },
   {
@@ -23,26 +17,34 @@
    "metadata": {},
    "source": [
     "## 1. 安装Jupyter lab  \n",
-    "    如要在自己电脑本地使用 Jupyter Lab 需要在命令提示符窗口（CMD）先用 Python 的包管理工具 pip 来安装：  \n",
-    "                    pip install jupyterlab  \n",
-    "    然后就可以用 \n",
-    "                     jupyter lab \n",
-    "    来运行 Jupyter Lab，打开 notebook 进行交互式编程的尝试"
+    "如要在自己电脑本地使用 Jupyterlab 需要在命令提示符窗口（CMD）先用 Python 的包管理工具 pip 来安装：\n",
+    "\n",
+    "`pip install jupyterlab`  \n",
+    "\n",
+    "然后就可以用\n",
+    "\n",
+    "`jupyter lab`\n",
+    "\n",
+    "来运行 Jupyterlab，打开 notebook 进行交互式编程的尝试。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 2.创建使用Notbook文件  \n",
-    "    （1）Notbook文件   \n",
-    "    菜单命令 New Notebook  创建一个新的Notbook文件  \n",
-    "    （2）单元格  \n",
-    "    Notbook文件是有若干单元格构成，单元格的类型可区分为：code、Markdown、RAW。 \n",
-    "    code类型的单元格中可以编写一条或多条python语句。按上方三角形Run按钮执行，或快捷键ctrl+enter。\n",
-    "    RAW类型的单元格是纯文本  \n",
-    "    Markdown类型的单元格支持Markdown格式，请自行查阅。      \n",
-    "    （3）使用工具栏命令可以增加，复制，删除，移动单元格。    "
+    "## 2.创建使用Notbook文件\n",
+    "\n",
+    "（1）Notbook文件   \n",
+    "File菜单 -> New Notebook 创建一个新的Notbook文件  \n",
+    "\n",
+    "（2）单元格  \n",
+    "Notbook文件是有若干单元格构成，单元格的类型可区分为：Code（代码）、Markdown、RAW。 \n",
+    "\n",
+    "Code类型的单元格中可以编写一条或多条python语句。按上方三角形运行（Run）按钮执行，或快捷键Ctrl+Enter；\n",
+    "RAW类型的单元格是纯文本；\n",
+    "Markdown类型的单元格支持Markdown格式，请自行查阅。     \n",
+    "\n",
+    "（3）使用工具栏命令可以增加，复制，删除，移动单元格。    "
    ]
   },
   {
@@ -75,20 +77,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "重要的事情说三遍\n",
-      "Hello Python World!\n",
-      "Hello Python World!\n",
-      "Hello Python World!\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# 示例2  多条语句\n",
     "#Fl1-1 重要的事情说三遍\n",
@@ -388,7 +379,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -402,7 +393,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.10"
+   "version": "3.9.5"
   }
  },
  "nbformat": 4,
diff --git a/Lab02.ipynb b/Lab02.ipynb
index aa3b330..c2c1156 100644
--- a/Lab02.ipynb
+++ b/Lab02.ipynb
@@ -4,24 +4,19 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "实践2 Python基本语法  \n",
-    "学习目标 \n",
-    "1.值具有类型，了解值的类型很重要；  \n",
-    "2.理解变量是值的抽象，可以帮助我们处理用户输入的任何值；  \n",
-    "3.掌握赋值语句，赋值语句是值与变量、变量与变量之间的桥梁。  \n",
-    "4.掌握基本运算，操作符是对数据进行操作的一些符号，最常用的有算术运算、大小比较、赋值、逻辑运算等；  \n",
-    "5.了解代码注释的语法和意义；  \n",
-    "6.了解浮点表示误差和规避方法； \n",
-    "7.了解 Python 中字符串的表示方法以及转义符；\n",
-    "8.了解如何使用 f-string；\n",
-    "9.掌握输入输出语句，输入输出语句提供了程序与用户的交互渠道，程序可以根据用户的输入，输出对应的结果。"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Python基本语法"
+    "# 实践2 Python基本语法 \n",
+    "\n",
+    "## 学习目标 \n",
+    "\n",
+    "1. 值具有类型，了解值的类型很重要；  \n",
+    "2. 理解变量是值的抽象，可以帮助我们处理用户输入的任何值；  \n",
+    "3. 掌握赋值语句，赋值语句是值与变量、变量与变量之间的桥梁。  \n",
+    "4. 掌握基本运算，操作符是对数据进行操作的一些符号，最常用的有算术运算、大小比较、赋值、逻辑运算等；  \n",
+    "5. 了解代码注释的语法和意义；  \n",
+    "6. 了解浮点表示误差和规避方法； \n",
+    "7. 了解 Python 中字符串的表示方法以及转义符；\n",
+    "8. 了解如何使用 f-string；\n",
+    "9. 掌握输入输出语句，输入输出语句提供了程序与用户的交互渠道，程序可以根据用户的输入，输出对应的结果。"
    ]
   },
   {
@@ -1224,7 +1219,7 @@
    ]
   },
   {
-   "cell_type": "raw",
+   "cell_type": "markdown",
    "metadata": {},
    "source": [
     "请思考在哪些情况下，程序会运行出错？\n",
@@ -1239,7 +1234,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -1253,7 +1248,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.10"
+   "version": "3.9.5"
   }
  },
  "nbformat": 4,
diff --git a/Lab03.ipynb b/Lab03.ipynb
new file mode 100644
index 0000000..9c02309
--- /dev/null
+++ b/Lab03.ipynb
@@ -0,0 +1,595 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 实践3 函数与模块\n",
+    "\n",
+    "1. 理解函数的基本概念；\n",
+    "2. 掌握Python内置函数的使用；\n",
+    "3. 掌握Python标准模块的引入；\n",
+    "4. 掌握math模块中常用数学函数的使用；\n",
+    "5. 理解函数的定义和调用。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1.函数"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "程序里的函数概念完全来自数学里的函数。我们先来看看数学里的函数。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 函数的基本概念"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "在数学里，我们可以定义一个函数，函数有一些*自变量*，也就是一些**输入**，**函数定义**就是定义如何通过这些输入计算出*函数的值*，也就是**输出**。下面是个典型的函数定义的例子："
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\n",
+    "\\begin{align}\n",
+    "f(a, b) = \\sqrt{a^2 + b^2}\n",
+    "\\end{align}\n",
+    "$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "函数定义好之后，随时可以用具体的值送进去算出一个具体的函数值，比如：\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\n",
+    "\\begin{align}\n",
+    "f(1, 2) = \\sqrt{5}\n",
+    "\\end{align}\n",
+    "$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\n",
+    "\\begin{align}\n",
+    "f(3, 4) = 5\n",
+    "\\end{align}\n",
+    "$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$\n",
+    "\\begin{align}\n",
+    "f(2, 6) = 2\\sqrt{10}\n",
+    "\\end{align}\n",
+    "$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "程序里的函数也是这样，我们先要定义函数，也就是定义它的名字（叫做 **函数名** *function name*）、若干输入变量（叫做 **参数** *argument*）以及如何通过输入变量算出函数的值（叫做 **返回值** *return value*）；一旦定义好，就可以在程序的其他地方随时使用这个函数，给它具体的参数值，它就给出具体的返回值。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 调用现成的函数"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "我们先看看怎么用函数，术语叫做函数**调用**（*call*），因为 Python 本身自带了很多已经定义好的函数，我们可以直接拿来用。其中有一些我们之前已经用过了：\n",
+    "* `print(a, b,...)`：在命令行输出界面打印输入的参数（可以是各种类型的数据）；\n",
+    "* `type(x)`：返回参数 x 的数据类型；\n",
+    "* `abs(x)`：返回参数 x（整数或者浮点数）的绝对值。\n",
+    "\n",
+    "这几个都是 Python 的内置函数，可以直接用。我们下面来看两个其他的例子。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "第一个例子是另一个 Python 内置函数，叫做 `isinstance(x, c)`，它有两个输入参数，第一个是一个数据，第二个是一个数据类型，如果第一个数据是第二个数据类型，`isinstance` 函数返回 `True`，否则就返回 `False`。所以 `isinstance` 可以用来判断某个值或者变量是不是某种类型，下面是例子："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "isinstance(a, int)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "isinstance(a, float)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "isinstance(g, float)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "isinstance(True, str)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "isinstance(True, bool)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "isinstance('abracadabra', str)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "isinstance(True, bool) and not isinstance('abracadabra', float)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2.模块\n",
+    "\n",
+    "第二个例子是 Python 的平方根函数 `math.sqrt(x)`，这个函数前面有个 `math`，这表示函数 `sqrt(x)` 不在 Python 的内置环境中，而是放在一个叫 `math` 的函数包（学名叫 **模块** *module*）里，关于模块我们以后会专门介绍。要使用这种函数，第一种方法是：\n",
+    "* 先 **引入**（*import*）对应的函数包；\n",
+    "* 使用时函数名前面要带上模块的名字，中间加个 `.`。\n",
+    "\n",
+    "就像下面这样："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4.0"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import math\n",
+    "math.sqrt(16)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "另外一种方法是，从对应的模块里指明引入这一个函数，使用时就不用带上模块名了："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "6.324555320336759"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from math import sqrt\n",
+    "sqrt(40)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "我们可以看到 `sqrt(x)` 函数可以接受整数或者浮点数输入，返回值是浮点数。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. 定义函数"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "有了 `sqrt(x)` 这个函数，我们可以定义一个函数来实现前面举例的那个数学里的函数 `f(a, b)` 了。在 Python 里函数的定义以关键字 `def` 开始，后面依次是函数名、小括号括起来的参数列表和一个冒号，之后的代码就是函数的算法定义，直到关键字 `return` 开始的 **返回语句**，这个返回语句会终止函数的运行，并把 `return` 后面的值作为函数的返回值，回到调用函数的地方。看起来有点抽象，我们看看例子： "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "5.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "from math import sqrt\n",
+    "\n",
+    "def f(a, b):\n",
+    "    return sqrt(a**2 + b**2)\n",
+    "\n",
+    "result = f(3, 4)\n",
+    "print(result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "上面的代码很短，但是很重要，我们务必要搞懂这里的每一个细节。\n",
+    "\n",
+    "首先第一行是引入 `sqrt(x)` 函数，因为我们下面定义的函数要用到它。\n",
+    "\n",
+    "然后是函数定义 `def f(a, b):`，关键字 `def` 打头，后面是函数名 `f`、参数列表 `(a, b)` 和一个冒号，这表示函数 `f` 接受两个参数，一个叫 `a` 一个叫 `b`。下面一行就是**函数体**（*function body*），里面可以写很多东西，只要最后有一个 `return` 指明函数返回值就行，注意 Python 的函数可以没有返回值（`return` 后面什么都不写就行了），也可以返回多个值（`return` 后面写多个值，用逗号隔开）。\n",
+    "\n",
+    "我们这个例子因为很简单，就一句话就能搞定：函数返回值等于 a 平方加 b 平方再开方。注意函数体的代码缩进了一些，和其他的行都是顶着行首书写不一样，这是 Python 的缩进规则要求的，下面的插播会做出解释。\n",
+    "\n",
+    "然后是调用函数的例子，它是这么进行的：\n",
+    "1. 首先用 3 和 4 作为参数来调用 `f()` 函数；\n",
+    "2. 函数 `f()` 开始执行，把值 3 赋给参数变量 a，4 赋给 b，然后执行函数体；\n",
+    "3. 函数体计算出返回值 5.0 并返回；\n",
+    "4. 用返回值 5.0 替换掉 `f()` 的位置，相当于执行赋值 `result = 5.0`\n",
+    "5. 用 5.0 作为参数值调用内置的 `print()` 函数，打印出 5.0（`print()` 没有返回值）。\n",
+    "\n",
+    "顺便说一句，熟练之后我们可以把后两行简化成一句 `print(f(3, 4))`，效果是完全一样的。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 插播：代码缩进"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "所谓代码缩进就是一行代码不顶格写，而是在行首空若干格再写。缩进可以很多层，比如 Python 中第一层缩进空四格，第二层缩进空八格，第三层缩进空十二格，依此类推。程序员都喜欢用“**等宽字体**（*fix-width font*）”，就是因为等宽字体在缩进时非常整齐美观。\n",
+    "\n",
+    "缩进是为了让代码层次更加鲜明地呈现出来。比如上面函数定义的代码，函数体的部分是“隶属于”函数定义 `def` 语句的，是它的组成部分，所以缩进一层表示这个从属关系；而后面的函数调用则不是，所以最后两行不缩进，和 `def` 语句平齐，代表是同一层级的代码。\n",
+    "\n",
+    "在 Python 中缩进是强制的，如果不进行正确的缩进，比如如果函数体没有正确的缩进，解释器会因为找不到必须的部分而报错。\n",
+    "\n",
+    "目前主流的程序编辑器都提供了自动缩进、自动排版的功能，在 VSCode 和 Jupyter Notebook 中书写代码时大部分时候都会自动正确的缩进，所以很方便。\n",
+    "\n",
+    "对于初学者来说，知道有这么回事，然后多看，慢慢就会习惯成自然，和多听多看学语言是差不多的道理。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4.函数的调用  \n",
+    "函数定义后，未经调用，是不会执行的。需要时使用函数调用语句。  \n",
+    "在函数调用的时候要求传递对应的值给形参，这个传递的值称为实际参数，简称实参。参数是可选的，也就是说函数可以不包括参数，例如：random.random() 就不包含参数。  \n",
+    "根据函数是否有返回值，函数的调用也是不同的。如果函数有返回值，函数调用的时候需要安排接受返回值。  \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "6.324555320336759"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# 可以是赋值语句，将返回值赋值给一个变量\n",
+    "z = f(2,6)\n",
+    "z"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "50.0"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# 可以是表达式语句，将返回值作为表达式的一个数值，继续参加运算\n",
+    "z = f(3,4)*10\n",
+    "z\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "11.180339887498949"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# 可以作为函数调用的实参\n",
+    "z=f(f(3,4),10)\n",
+    "z\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 函数的意义"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "函数是编程中最重要的概念之一。实现它有助于我们实现程序的“**模块化**（*modulization*）”，我们可以把特定的工作用一个函数来实现，然后在需要的地方反复地调用它。这是一种代码重用的方法，一个函数就好像乐高积木里的一个组件，我们可以通过组合各种不同功能的函数来实现复杂的目标。\n",
+    "\n",
+    "函数还是协作编程的基础。如果我们实现了一个很有用的函数，我们可以写一个文档说明函数的输入参数和返回值是什么，这样的文档叫做**调用接口**（*interface*），别人都可以照此使用我们写的函数，甚至不需要了解它是怎么实现的（比如我们就直接拿了 `math.sqrt()` 来用而不需要自己写一个）。函数天生就把自己的接口和实现分离开，让协作和复用成果更容易。\n",
+    "\n",
+    "**模块化** 和 **接口独立** 是编程时最重要的两个思维模型（没有之一），我们在后面还会深入介绍。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 小试身手\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### （1）使用math模块的数学函数。  \n",
+    "导入数学库math。然后输入以下表达式理解math中函数的使用，注意结果值的数据类型。  \n",
+    "math.sqrt(2*2+3*3)、 math.log10(100)、 math.exp(2)、math.fmod(4,3)、math.sin(2*math.pi)、\n",
+    "math.gcd(12,9)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[数学库math](https://docs.python.org/zh-cn/3/library/math.html)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### （2）自定义求矩形面积的函数"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#定义一个函数getArea(length,width)，计算长为length,宽为width的矩形面积。  \n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#试着用不同的方式调用getArea函数，验证函数的正确性\n",
+    "\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Lab04.ipynb b/Lab04.ipynb
new file mode 100644
index 0000000..0cf7e76
--- /dev/null
+++ b/Lab04.ipynb
@@ -0,0 +1,628 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 实践4 逻辑判断与分支\n",
+    "\n",
+    "## 学习目标\n",
+    "1. 掌握if...else语句\n",
+    "2. 掌握逻辑表达式的书写\n",
+    "3. 理解万物皆为布尔值\n",
+    "4. 掌握选择结构的算法构造\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 逻辑判断与分支"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "如果源代码是我们写出来的故事，那么“逻辑判断与分支”就是故事中的情节编排，是场景之间的关联、排列和衔接——这一点程序和小说、影视剧不那么相近，倒是更像电子游戏。游戏是互动性最强的艺术形式，可以根据玩家的行为走向不同的情节，发生不同的事件和冲突，这种分支多样性极大地增加了表现力和趣味性。\n",
+    "\n",
+    "程序也一样，如果一个程序只能顺序一条一条指令执行，能表达的东西就太少了。我们需要根据输入的不同执行不同的指令，最终给出不一样的结果，这样程序才有价值。所以所有的编程语言都会提供逻辑判断和分支执行的能力。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1.if...else 语句"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "所谓分支，其实也很简单，就是“如果这样就 A 否则就 B”，通过这个句式的组合可以实现无穷无尽的变化，这个句式翻译成 Python 的语法就是：\n",
+    "\n",
+    "```python\n",
+    "if X:\n",
+    "    A\n",
+    "else:\n",
+    "    B\n",
+    "```\n",
+    "\n",
+    "X 是一个“逻辑判断”，其结果要么是真（*True*）要么是假（*False*）；A 和 B 是两个代码段（*code block*），分别缩进以表示从属于 `if` 和 `else`。上面的代码意思是：如果 X 是真就执行代码段 A，否则就执行代码段 B。\n",
+    "\n",
+    "Python 还可以连着写好几个 `if`，比如：\n",
+    "\n",
+    "```python\n",
+    "if X:\n",
+    "    A\n",
+    "elif Y:\n",
+    "    B\n",
+    "else:\n",
+    "    C\n",
+    "```\n",
+    "\n",
+    "这里的 `elif` 是 *else if* 的简化写法，整个意思是：如果 X 是真就执行 A（不管 Y 如何），否则继续判断 Y——如果 Y 是真就执行 B，否则就执行 C。\n",
+    "\n",
+    "下面我们重点看看 X、Y 这些所谓“逻辑判断”可以是什么东西。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##  2.逻辑表达式"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "只要最终给出一个逻辑真值或假值的东西都可以算作“逻辑判断”，我们大致分分类可以有这么些：\n",
+    "* 布尔类型的变量或者值，要么是 `True` 要么是 `False`；\n",
+    "* 上一章介绍的**大小比较操作符**的运算结果，例如 `a <= 6` `a + b == c` 这类；\n",
+    "* 返回布尔值的函数，例如我们上一章介绍的 `isinstance()`；\n",
+    "* 上面这些东西通过上一章介绍的**逻辑运算操作符**组合起来，例如 `(a > 1) and (a <= 6)` `isinstance(x, int) or isinstance(x, float)`。\n",
+    "\n",
+    "这些东西通称“逻辑表达式”，因为其结果最终都是一个逻辑真值或者假值，根据其真假 `if...else` 语句就知道到底应该执行哪一个分支。我们来看例子。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from random import randrange\n",
+    "n = randrange(1, 100)\n",
+    "if n % 2 == 0:\n",
+    "    print(n, '是偶数')\n",
+    "else:\n",
+    "    print(n, '是奇数')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "上面的代码首先引入 `random` 模块里的一个函数 `randrange()`，然后调用这个函数来生成一个 1~100 之间的随机数并赋给 n——我们先不去细究这里面的东西，知道这个结果就好，关键是下面的 `if...else` 语句：如果 n 除以 2 的余数是 0（还记得上一章我们介绍的整除操作符 `//` 和 `%` 吧），就打印 ‘n 是偶数’，否则打印 ‘n 是奇数’。由于 n 是随机生成的一个数，所以你可以反复多次运行上面这段代码（运行的方法是选择上面这个 *cell*，按 ⌃+回车），看看不同的结果。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "有了逻辑判断和条件分支，我们可以做好多事情了，比如我们可以实现一个算绝对值的函数："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def abs(x):\n",
+    "    if x >= 0:\n",
+    "        return x\n",
+    "    else:\n",
+    "        return -x"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "这个函数非常简单，如果是大于等于零的数就直接返回这个数，否则返回它的相反数，我们可以测试下："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "abs(42)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "abs(-3.14)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "我们还可以实现一个我们自己的 `type()` 函数，和官方的 `type()` 功能也差不多，即返回一个变量或者值的数据类型："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def type_0(x):\n",
+    "    if isinstance(x, bool):\n",
+    "        return 'bool'\n",
+    "    elif isinstance(x, int):\n",
+    "        return 'int'\n",
+    "    elif isinstance(x, float):\n",
+    "        return 'float'\n",
+    "    elif isinstance(x, str):\n",
+    "        return 'str'\n",
+    "    else:\n",
+    "        return 'unknown'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "type_0(42)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "type_0('abracadabra')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "type_0(False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "type_0([1, 2, 3])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "最后一个例子显示出我们的 `type_0` 实现和系统的 `type` 还是有点差距，不过没关系，我们才刚开始嘛。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##  3.万物皆为布尔值"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "我们上一节列出了几类逻辑表达式，它们都可以放在 `if` 后面做逻辑判断，但可以放在 `if` 后面的远不止这些，事实上**几乎任何东西**都可以。因为 Python 提供了一组规则来判断一个值“相当于”逻辑真还是假，这种定义是在所谓“合理类比”和方便性的基础上做出的，比如：\n",
+    "* 数字 0 “相当于”假，而其他数字都相当于真；\n",
+    "* 空字符串“相当于”假，非空的字符串“相当于”真。\n",
+    "\n",
+    "其他很多情形也类似，一般来说 0 啊、空啊之类的都“相当于”假，其他就算真了。如果我们搞不清楚某个东西相当于真还是假，可以借助于内置函数 `bool()`，这个函数可以把任何东西变成布尔值（`True` 或者 `False`），下面是一些例子："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bool(42)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bool(0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bool(0.0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bool('')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bool('abracadabra')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bool('0') # 这是一个非空字符串，不要和 bool(0) 搞混哦~"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bool([1, 2, 3]) # 和字符串类似，非空列表相当于真，空列表相当于假"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bool([])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "这种“相当于”的逻辑，可以帮助我们写出更简洁的代码，比如下面两段代码是完全等价的："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = 42\n",
+    "if n != 0:\n",
+    "    a = a / n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = 42\n",
+    "if n:\n",
+    "    a = a / n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "下面两段也完全等价："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s = input('请输入您的姓名')\n",
+    "if s == '':\n",
+    "    print('姓名不可为空，请重新输入')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s = input('请输入您的姓名')\n",
+    "if not s:\n",
+    "    print('姓名不可为空，请重新输入')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 案例  求解BMI问题（2）判断BMI指标等级（选择结构）  \n",
+    "计算BMI指数可用于评价身体状况。用于评价身体状况的指标等级分为以下四部分：  \n",
+    "\t轻体重：BMI<18.5  \n",
+    "\t健康体重：18.5≤BMI<24  \n",
+    "\t超重：24≤BMI<28  \n",
+    "\t肥胖：28≤BMI  \n",
+    "  "
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "编写程序，根据体重和身高来判断BMI指标等级。该问题的IPO描述如下：\n",
+    "输入：身高和体重\n",
+    "处理：STEP1: 计算 BMI = 体重(kg) ÷ 身高2(m2)\n",
+    "      STEP2: 根据计算得到的BMI值判断指标等级\n",
+    "输出：BMI指标等级\n"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "算法描述\n",
+    "1 输入身高height\n",
+    "2 输入体重weight\n",
+    "3 计算BMI = weight / height2\n",
+    "4 如果BMI>=28 则 等级=肥胖\n",
+    "  如果BMI<18.5则 等级=轻体重\n",
+    "  如果18.5≤BMI<24则 等级=健康体重\n",
+    "  如果24≤BMI<28 则 等级=超重\n",
+    "5 输出BMI指标等级\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### （1）使用if语句判断指标等级\n",
+    "为了判断BMI指标等级，实际上要做的就是判断变量value的数值最终落入哪一个区间。本任务中一共有四个区间，分别为轻体重、健康体重、超重和肥胖。最容易想到的方法是使用四个if语句。\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#【例1】使用if语句判断指标等级\n",
+    "height = float(input(\"请输入你的身高(m):\"))\n",
+    "weight = float(input(\"请输入你的体重(kg):\"))\n",
+    "value = weight / pow(height, 2)\n",
+    "if value < 18.5:\n",
+    "    print(\"轻体重\")\n",
+    "if 18.5 <= value < 24:\n",
+    "    print(\"健康体重\")\n",
+    "if 24 <= value < 28:\n",
+    "    print(\"超重\")\n",
+    "if 28 <= value:\n",
+    "    print(\"肥胖\")\n"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "在例1中，一共有4条if语句，分别判断value的值是不是在轻体重、健康体重、超重和肥胖之间，如果value的值满足了某一个if中的判断条件，那么就执行if语句内，同一缩进层次下的所有代码。\n",
+    "可以看到，4条if语句对value的判断囊括了整个有理数集，一般情况下，给定任意数值，程序都会有输出。\n",
+    "Python与C++/Java不同，Python允许使用类似于18.5 <= value < 24的表达式语句，它等价于18.5 <= value and value < 24。但是可以发现写4个if语句的效率不高，对于每个if条件它都必定判断一次，哪怕BMI指数的数值已经落入了之前的区间，并且这个数值已经不会再落入之后的区间。\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### （2）使用if-elif-else语句判断指标等级\n",
+    "使用if-elif-else语句则不会做这么多无用的操作。if-elif-else满足了一个条件之后，执行该条件下的语句块，然后跳出该选择结构。如果都不满足，则执行else分支下的语句块。例2使用if-elif-else结构改写了原程序。请读者对照例2-2-1与例2-2-2，比较仅使用if语句和使用if-elif-else结构的差别。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#【例2】使用if-elif-else结构改写程序【例1】\n",
+    "height = float(input(\"请输入你的身高(m):\"))\n",
+    "weight = float(input(\"请输入你的体重(kg):\"))\n",
+    "value = weight / pow(height, 2)\n",
+    "if value < 18.5:\n",
+    "    print(\"轻体重\")\n",
+    "elif 18.5 <= value < 24:\n",
+    "    print(\"健康体重\")\n",
+    "elif 24 <= value < 28:\n",
+    "    print(\"超重\")\n",
+    "else:\n",
+    "    print(\"肥胖\")\n"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "通过if-elif-else语句，程序按顺序依次判断每个分支的条件。一旦条件匹配成功，进入分支执行分支语句，然后继续执行if-elif-else后面的语句，之后的分支条件表达式将不再运算，这样做可以使程序运行的效率提升。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### （3）改进程序  \n",
+    "先给出程序【例3】，请观察改动部分，并尝试根据if-elif-else的特性，指出这样做的原因。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#【例3】修改条件表达式\n",
+    "height = float(input(\"请输入你的身高(m):\"))\n",
+    "weight = float(input(\"请输入你的体重(kg):\"))\n",
+    "value = weight / pow(height, 2)\n",
+    "if value < 18.5:\n",
+    "    print(\"轻体重\")\n",
+    "elif value < 24:\n",
+    "    print(\"健康体重\")\n",
+    "elif value < 28:\n",
+    "    print(\"超重\")\n",
+    "else:\n",
+    "    print(\"肥胖\")\n"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "通过对比例2与例3，可以发现，在两个elif条件判断中的表达式简洁了一些。\n",
+    "多分支结构依次评估条件1，条件2，...，直到找到第一个结果为True的条件，按照BMI问题来举例，在进行第一个分支（value < 18.5）的判断的时候，如果不满足第一个分支条件，那么在进行接下来的分支选择时，是已经默认了value是大于等于18.5的。所以，在第二个分支入口处判断18.5 <= value实际上是没有意义的，这仅仅会增加程序运行的开销。对于第三个分支（24 <= value < 28）也是相同的原理。\n"
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "###  （4） 调试运行\n",
+    "当编辑程序完成，并消除了语法错误，程序可以运行，并不代表程序是正确的，还要通过测试来检查程序的正确性，需要设计测试用例来检查程序的运行是否达到预期的设计目标。  \n",
+    "测试用例（Test Case）是为某个特殊目标而编制的一组测试输入、执行条件以及预期结果，以便测试某个程序路径或核实是否满足某个特定需求。  \n",
+    "本例中包含多分支语句，在对多分支语句的测试用例的设计中，最起码的测试用例设计要包含所有的分支和节点值。在本例中，多分支的测试要测试4个分支和3个节点值。测试用例设计如下所示。前4个测试用例测试进入分支是否正确，后三个测试用例测试节点值进入分支是否正确。  \n",
+    "![image.png](attachment:image.png)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 小试身手"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "1.编写程序：输入半径r(浮点数)，输出以r为半径的圆的面积。使用math库中的数学函数math.pi，如果输入数据为负数，输出\"ERROR\"  \n",
+    "运行示例如下：  \n",
+    "示例一：\n",
+    "r=3.5\n",
+    "38.48451000647496\n",
+    "示例二：  \n",
+    "r=-2.9\n",
+    "ERROR"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# math.pi的导入方法是在程序开头加上下面一行代码，程序中用 math.pi 表示 pi\n",
+    "import math\n"
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "2.改错题，程序实现的功能是按照下面的分段函数，对输入的整数x，输出对应的y值。对于超出范围的整数x，输出“ERROR”。\n",
+    "![image.png](attachment:image.png)\n",
+    "下面的程序有三处错误，请找出并修改，试程序能正常运行。  \n",
+    "测试用例：  \n",
+    "输入：12    输出：ERROR  \n",
+    "输入： 6    输出：36  \n",
+    "输入：-1    输出：5  \n",
+    "输入： 5    输出：19  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = input()\n",
+    "if x > 10 or x < -10:\n",
+    "    print(\"ERROR\")\n",
+    "else:\n",
+    "    if x < 0:\n",
+    "        y = 2 * x * x * x + 4 * x * x + 3\n",
+    "    elif x < 6:\n",
+    "        y = x + 14\n",
+    "    else  x <= 10:\n",
+    "        y = 6 * x      \n",
+    "print(y)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Lab05.ipynb b/Lab05.ipynb
new file mode 100644
index 0000000..27847bd
--- /dev/null
+++ b/Lab05.ipynb
@@ -0,0 +1,419 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 实践5 循环结构\n",
+    "\n",
+    "## 学习目标\n",
+    "1. 理解循环就是反复执行一组特定操作；  \n",
+    "2. 掌握 `for` 循环，可以针对一组数据进行循环；  \n",
+    "3. 掌握 `while` 循环，根据循环条件成立与否来决定循环是否继续；  \n",
+    "4. 理解可以使用 `continue` 和 `break` 语句来改变循环的执行流程。\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 循环结构"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "循环也是一种常见结构，它代表了一种常见模式：批处理。我们在现实生活中也经常面对“批处理”这种模式：\n",
+    "* 我们乘坐地铁，要坐十站去到目的地，那么就是把“乘坐一站地铁”循环十遍；\n",
+    "* 我们要洗一大串葡萄，就是把“洗一颗葡萄”循环 N 遍；\n",
+    "* 我们要学完这个部分，就是不断循环“学习下一章”直到“本部分没有更多章”。\n",
+    "\n",
+    "我们写程序也是如此，计算机特别擅长的就是重复劳动，不知疲倦而且不走样，我们的程序经常是一次处理一组数据，对其中的每个数据做一些操作，然后下一个，然后下一个……直到这组数据都处理完，这就是循环的基本概念了。\n",
+    "\n",
+    "循环可以用下面的逻辑来表述：\n",
+    "1. 从一组数据 S 中取出下一个数据 x => x 是一个变量，这对应一个赋值语句；\n",
+    "2. 对 x 执行若干操作 => 这对应一个代码段，里面可以有各种操作符和函数；\n",
+    "3. 如果 S 中还有未取出的数据，则回到第1步继续 => 这对应一个逻辑判断 `if...else`，但这个“回到第1步”是什么呢？\n",
+    "4. 结束。\n",
+    "\n",
+    "上面第3步中的“回到第1步”就是循环实现的关键操作，这个要怎么做呢？\n",
+    "\n",
+    "最早的一批编程语言对这个操作的实现真的就是按照“回到第1步”的字面意思做的，就是使用 *goto* 指令的**跳转语句**，这个语句让计算机跳到指定的一行执行，这样我们就可以复用上面的第1和第2步，不断的循环执行它们。不过后来 *goto* 语句闯了祸，被人类封印了，说白了就是 *goto* 太自由太强大了，可以在程序中任意的指定下一个执行的语句，当程序变大变复杂时导致程序的执行顺序非常难以预测，程序就很容易出错。\n",
+    "人们转而使用一种“有限制的跳转”来实现循环，Python 支持两种形式的循环语句，分别是 **for 循环** 和 **while 循环**，我们下面分别来介绍。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## for 循环"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Python 的 `for` 循环可以对一组数据做循环，比如给出一个列表，可以针对列表里每个元素按顺序循环一遍。下面是例子："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "primes = [2, 3, 5, 7]\n",
+    "for prime in primes:\n",
+    "    print(prime)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "列表我们还没正式介绍过，但已经零零星星出现过几次，这个东西非常重要，而且很多事情和它有关，我们在后面介绍会重点介绍列表，在此之前我们只要知道：列表就是方括号括起来的一串数据，里面每个数据可以是任何类型，并且是有序排列的。就像上面例子里的 `primes`，方括号括起来的四个素数。\n",
+    "\n",
+    "而 `for` 循环的语法就像上面展示的：\n",
+    "1. `for prime in primes` 的意思是，从 `primes` 中取出下一个元素，将其赋值给 `prime`（这个变量叫做“**循环变量**”），然后运行下面缩进的代码段；\n",
+    "2. 在 `for` 语句最后冒号下面缩进的代码段，叫做“**循环体**”，是循环中反复执行的片段，这里我们简单地调用 `print()` 函数打印循环变量 prime 的值；\n",
+    "3. 循环体执行完毕就回到第1步执行 `for` 那一行，直到 `primes` 中取不出下一个元素，即列表循环完毕，整个循环结束。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Python 提供有一个内置函数 `range()` 可以构造任何整数等差数列，经常拿来和 `for` 循环一起用，在官方手册中 `range()` 函数的参数是[这么定义](https://docs.python.org/3.7/library/functions.html#func-range)的：\n",
+    "\n",
+    "```python\n",
+    "range(stop)\n",
+    "range(start, stop[, step])\n",
+    "```\n",
+    "\n",
+    "上面的文档说明 `range()` 这个函数有两个版本：第一个接受一个参数；第二个接受三个参数，其中最后一个有缺省值，所以可以不提供（方括号括起来的部分表示有缺省值、可提供可不提供的参数，这个方括号和上面表示列表的不是一回事哦）：\n",
+    "* 第一个版本中，唯一的参数是 `range()` 要构造的数列的上限，`range(stop)` 会输出从 `0` 到 `stop-1` 的 整数列；\n",
+    "* 第二个版本中，前两个参数分别是 `range()` 要构造的数列的下限和上限，`range(start, stop)` 会输出从 `start` 到 `stop-1` 的 整数列；如果还提供了第三个参数 `step`，这是等差数列的**公差**，`range(start, stop, step)` 会输出 `[start, start+step, start+step*2,...]` 这样一列整数，最大不超过 `stop-1`。\n",
+    "\n",
+    "下面是一些例子："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "list(range(6))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "注意我们在 `range()` 函数外面套了一个函数 `list()` 来把 `range()` 的输出结果转换为一个列表，这样方便我们看。\n",
+    "\n",
+    "> 可能有善于思考的你会问：`range()` 的输出还要用 `list()` 来“转换为列表”，那 `range()` 输出的是什么呢？这是个好问题，`range()` 输出的是一个“**迭代器**（*iterator*）”，是 Python 非常有特色也非常强大的工具，可惜目前我们还不容易搞清楚这个东西，我们把它放在第四部分中，学完迭代器顺便还能知道 `for` 循环的本质是什么。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "list(range(2, 10)) # 注意 range() 输出是从 start 开始，到 stop-1 结束，也就是说，不包含后一个参数本身"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "list(range(2, 10, 1)) # step 的缺省值就是 1，所以这句和上一句完全等价"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "list(range(2, 10, 3)) # 这次指定了 3 作为公差，"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`for` 循环用的那个列表不一定是数字，别的类型也都可以，比如在 Python 中字符串可以看作其中每个字符组成的列表，所以下面的代码会打印出字符串 s 中的每个字符："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s = 'abracadabra'\n",
+    "for c in s:\n",
+    "    print(c)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "其实 `for` 可以循环的东西远不止列表，我们在后面介绍迭代器的时候会再回来讨论 `for` 循环。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## while 循环"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`while` 循环是更一般化的一种循环结构，基本上就是我们在本章开头描述的“只要某条件成立就继续循环，否则结束循环”的逻辑，那个使得循环继续的条件叫做“**循环条件**”。我们还是用例子来说明："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "count = 0\n",
+    "while count < 5:\n",
+    "    print(count)\n",
+    "    count += 1\n",
+    "    \n",
+    "print('Loop ends.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "上面的代码一开始变量 `count` 值为 0，然后开始一个 `while` 循环，循环条件是一个逻辑表达式 `count < 5`，只要这个条件成立就会反复执行它下面缩进的代码段，每执行完一次都会重新检查一下循环条件，如果循环条件不成立（逻辑表达式的值为 *False*）则循环不会继续，直接跳到循环体的后面执行了。\n",
+    "\n",
+    "在这个例子中，循环体先打印 `count` 的值，然后对 `count` 执行 +1 的操作，这样循环若干次之后，`count` 的值会达到 5，从而使得循环条件 `count < 5` 不再成立，于是循环就结束了，跳到循环体的后面，打印出 *Loop ends*。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "和 `for` 循环不一样，`while` 的循环条件非常自由，完全由我们的代码来控制，这样的好处是可以处理各种情况的循环，坏处是，有可能玩砸掉。试想上面的循环，如果我们在循环体里没有给 `count` 执行 +1，那么 `count` 的值就永远也不会达到和超过 5，这个循环就会无限进行下去，直到这个页面挂掉。所以在写 `while` 循环时要特别小心的检查，确保循环条件是会终止的，避免出现无限循环的情况。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## break 和 continue"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "在 for 和 while 的循环体里可以执行 `break` 和 `continue` 两个命令：\n",
+    "* `break` 直接终止整个循环，跳到循环体之后的代码执行；\n",
+    "* `continue` 跳过本次循环余下的代码，直接回到 `for`（取下一个元素）或者 `while`（进行循环条件检查）。\n",
+    "\n",
+    "这两个命令一般用于特定边界情况的处理。我们来看几个例子。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for x in range(10):\n",
+    "    if x % 2 == 0:\n",
+    "        continue\n",
+    "    print(x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "上面的代码在 0~9 的数列中循环，如果循环变量 `x` 是偶数就跳过循环体剩下的部分（即 `print(x)` 这一句），继续下一个，所以最后只会打印出所有奇数（偶数都被 `continue` 跳过了）。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from random import randrange\n",
+    "\n",
+    "while True:\n",
+    "    n = randrange(-2, 5) # randrange 返回一个给定范围的随机整数\n",
+    "    if n < 0:\n",
+    "        break\n",
+    "    elif n % 2 == 0:\n",
+    "        print(n, 'is even')\n",
+    "    else:\n",
+    "        print(n, 'is odd')"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "还是使用 `randrange()` 函数来生成一个随机整数。注意上面 `while` 的循环条件是固定真值，所以后面的循环体会一直循环执行，但不用担心，因为遇到 `break` 循环就会终止。在循环体中我们用 `randrange()` 来生成一个 -2 到 4 之间的整数，如果是负数就执行 `break` 终止循环，否则看取出来的是奇数还是偶数，相应的输出一句话。试着自己运行下这个程序看看。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 案例：求解BMI问题（3）-- 打印BMI对照表（循环结构）"
+   ]
+  },
+  {
+   "attachments": {
+    "image-2.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "【例2-3 】编写程序打印BMI对照表。  \n",
+    "  \n",
+    "![image-2.png](attachment:image-2.png)"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "算法：  \n",
+    "编程打印一张BMI对照表需要用到循环结构，根据BMI对照表逐行逐列实现，先按身高建立外层循环结构，循环体解决一行的数据。再按体重建立内层循环结构，循环体计算并输出一个BMI值。  \n",
+    "1 打印BMI对照表的第一行  \n",
+    "2 循环 从1.45m到1.99m，步长为0.3m  \n",
+    "    2.1 打印当前身高值  \n",
+    "    2.2 循环 从40kg到80kg，步长为3kg  \n",
+    "        2.2.1 计算当前身高体重下的BMI值  \n",
+    "        2.2.2 输出BMI值  \n",
+    "    2.3 换行  \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"m\\kg\", end='\\t')\n",
+    "for weight in range(40, 81, 3):\n",
+    "    print(str(weight) + \"kg\", end='\\t')\n",
+    "print()\n",
+    "for height in range(145, 199, 10):\n",
+    "    height = height / 100\n",
+    "    print(str(height) + \"m\", end='\\t')\n",
+    "    for weight in range(40, 81, 3):\n",
+    "        value = weight / height ** 2\n",
+    "        print(\"{:.1f}\".format(value), end='\\t')\n",
+    "    print()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 小试身手"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "1.使用while语句编写程序，输入一个小于等于12的整数n，逐个输出字符串 '人生苦短我用python' 中前n个字符。\n",
+    "例如\n",
+    "输入：4   输出：人生苦短\n",
+    "提示：\n",
+    "（1）s[i]表示s中第i+1个字符；\n",
+    "（2）print(...,end=\"\")可以不换行。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n=___________\n",
+    "s = '人生苦短我用python'\n",
+    "i=0\n",
+    "while( ________    ):\n",
+    "    print(_________,end=\"\")\n",
+    "    i=i+1\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "2.使用for语句编写程序，输入一个小于等于12的整数n，逐个输出字符串 '人生苦短我用python' 中前n个字符。\n",
+    "例如\n",
+    "输入：4   输出：人生苦短\n",
+    "提示：\n",
+    "（1）s[0:n]表示截取s中前n个字符；\n",
+    "（2）print(...,end=\"\")可以不换行。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n=_____________\n",
+    "s = '人生苦短我用python'\n",
+    "for ch in___________:\n",
+    "    print(________________)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Lab06.ipynb b/Lab06.ipynb
new file mode 100644
index 0000000..b2c7917
--- /dev/null
+++ b/Lab06.ipynb
@@ -0,0 +1,345 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 实践6：异常处理\n",
+    "\n",
+    "## 学习目标：\n",
+    "\n",
+    "1. 了解程序处理用户或其他系统提供的输入时可能出现预期之外的异常状况，可以使用异常处理来捕获异常并进行应急处置；\n",
+    "2. 理解 Python 异常处理的模板含义；\n",
+    "3. 通过例子初步了解异常处理可能的应用场景。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "异常处理是个很重要，也有点难度的概念。我们先尝试理解基本的概念，后面再不断通过实践来加深掌握。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "我们前面说过，大多数程序的工作都是：接受输入，对输入进行处理，然后输出结果。这里有个很重要的理念，是所有资深程序员都习惯成自然的认知，那就是“输入是不可控的”，输入可能是用户通过键盘鼠标触控屏输入的，也可能是读取某个设备上一个程序的输出，简言之，都存在不可期的情况。\n",
+    "\n",
+    "假定我们期待用户或者某个程序给我们一个不为 0 的整数，我们要拿来做除数算出一个值，如果来的不是整数是个小数怎么办？或者就是个 0 怎么办？或者干脆就不是个数怎么办？\n",
+    "\n",
+    "还有依赖于外部设备的各种异常状况：如果我们从某个程序读一个数，但是那个程序死掉了，一直没给我们数，我们一直等着卡死在这里？或者我们要向打印机输出一个报表，但是打印机被人踢掉了电源线，一直不响应怎么办？"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "所有这些错误都在程序运行时才会出现，程序写出来是没有错的，运行时出现奇怪的异常状况，程序又没有好好处理的话，就会出现灾难，这些运行时出现的异常状况就叫**运行时错误**（*runtime error*）或者**运行时异常**（*runtime exception*）。现代编程语言一般都提供标准的异常处理方案，让我们可以写程序来处理这类异常。\n",
+    "\n",
+    "Python 提供的异常处理机制可以用下面的模板来说明：\n",
+    "\n",
+    "```python\n",
+    "try:\n",
+    "    # 把有可能出现异常的代码放在 try 后面\n",
+    "    # 当出现异常时解释器会捕获异常\n",
+    "    # 并根据异常的类型执行后面的对应代码块\n",
+    "    do_something_nasty()\n",
+    "except ValueError:\n",
+    "    # 如果发生 ValueError 类型的异常则执行这个代码块\n",
+    "    pass\n",
+    "except (TypeError, ZeroDivisionError):\n",
+    "    # 可以一次指定几个不同类型的异常在一起处理exceptions\n",
+    "    # 如果出现 TypeError 或者 ZeroDivisionError 则执行这个代码块\n",
+    "    pass\n",
+    "except:\n",
+    "    # 所有上面没有专门处理的类型的异常会在这里处理\n",
+    "    pass\n",
+    "else:\n",
+    "    # 当且仅当 try 代码块里无异常发生时这个代码块会被执行\n",
+    "    pass\n",
+    "finally:\n",
+    "    # 无论发生了什么这个代码块都会被执行\n",
+    "    # 通常这里是清理性的代码，比如我们在 try 里面打开一个文件进行处理\n",
+    "    # 无论过程中有没有异常出现最后都应该关闭文件释放资源\n",
+    "    # 这样的操作就适合在这里执行\n",
+    "```\n",
+    "\n",
+    "上面出现的关键字 `pass` 的意思是“什么也不做”，Python 语法需要有点什么，但是我们暂时什么都不想做的时候放上一个 `pass` 就可以了。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "以 `try` 开始的异常处理结构可以包含所有这些模块，但并不是都必须有，但至少应该有一个 `except` 或者 `finally`。\n",
+    "\n",
+    "Python 有很多[内置的运行时错误类型](https://docs.python.org/3/library/exceptions.html#bltin-exceptions)可以直接使用，比如我们上面看到的：\n",
+    "* `TypeError`：当一个操作或者函数收到的参数类型不对，或者一个类型的对象不支持某个被请求的操作时抛出这个异常；\n",
+    "* `ValueError`：当一个操作或者函数收到的参数类型对但是值不合法时抛出这个异常；\n",
+    "* `ZeroDivisionError`：出现 0 作除数的情况时抛出这个异常。\n",
+    "\n",
+    "我们来看几个官方指引中的例子并稍作解释。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "while True:\n",
+    "    try:\n",
+    "        x = int(input('Please enter a number: '))\n",
+    "        break\n",
+    "    except ValueError:\n",
+    "        print('Not a valid number. Try again...')\n",
+    "\n",
+    "print('Your number is:', x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "这里用一个无限循环中的 `input()` 方法来获取用户输入，然后把输入的字符串用 `int()` 方法转换为一个整数；如果用户没有输入一个整数，`int()` 方法会抛出一个 `ValueError`，于是执行 `except ValueError` 后面的代码块，打印一个提示，然后继续 `while True`，再次提示用户输入；如果 `try` 代码段里第一句执行成功（用户输入成功转换为整数并赋值给 x 变量），那就继续执行后面一句 `break` 终止循环，继续执行其他代码（这时候 x 里面已经有了用户输入的整数）。\n",
+    "\n",
+    "在这里异常处理确保用户输入可以转换为整数且赋值给 x，否则就不会继续执行下去，经过这样的处理，在这段代码之后我们可以相当有把握的说：x 里面有个合法的、用户输入的整数值；同时用户不管怎么乱输入也不会对程序构成致命影响，我们预期到可能出现的问题，并做了合理处理。这就是异常处理的意义所在。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def this_fails():\n",
+    "    x = 1/0\n",
+    "\n",
+    "try:\n",
+    "    this_fails()\n",
+    "except ZeroDivisionError as err:\n",
+    "    print('Handling run-time error:', err)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "这个例子展示了用 `except ZeroDivisionError as err` 这样的语法来取得一个 `err` 对象，这个对象是系统定义的 `Exception` 类型或者子类，里面存放着发生异常时的具体上下文信息，可以打印出来也可以做别的处理。\n",
+    "\n",
+    "我们还可以从 `Exception` 派生出我们自己的异常类型，并使用 `raise` 关键字来在出现某种情况时抛出我们定义的异常，并在文档中做出清晰的说明。这样使用我们代码的其他程序员就知道什么情况是我们程序处理不了的，会抛出什么样的异常，并在调用端用捕获异常进行处理。\n",
+    "\n",
+    "建议学习 [关于 Python 异常处理的官方教程](https://docs.python.org/3/tutorial/errors.html) 来了解更多。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 案例 求直角三角形的直角边\n",
+    "程序实现功能为：让用户输入直角边和斜边的长度，输出第二条直角边的长度。\n",
+    "要求：提示用户所有的非法输入：非ASCII数字、直角边大于斜边、浮点数,并将这些非法输入所引起的异常用一个except子句匹配；异常处理完后，程序立刻终止。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "try:\n",
+    "    a=int(input('直角边长度：'))\n",
+    "    c=int(input('斜边长度：'))\n",
+    "    print(f'直角边长度为 {a}，斜边长度为 {c}')\n",
+    "    print(f'第二条直角边长度为：{ math.sqrt(c**2-a**2)}')\n",
+    "except (ValueError):\n",
+    "    print('请使用整数，斜边必须大于直角边')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "直角边大于斜边所产生的对负数开根号、输入非ASCII正整数这两种错误，都会引发同样的异常——ValueError。用except扑捉ValueError，输出提示信息。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 小试身手"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "1. 运行下面程序段，认识默认异常处理器，总结异常名和产生异常的场合"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    " for i in range(1,5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for1 + i"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "12/0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "math.sqrt(-2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "'1'+1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "1+'1'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=5\n",
+    "str(a)+6"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x=10\n",
+    "y=2.5\n",
+    "f\"x={x:d},y={y:d}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "int('hello')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    " true+5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "1000.1**333"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "2. 编写程序以完成如下两个表达式的计算\n",
+    "a/(a-b-1)\n",
+    "a**b\n",
+    "要求：a、b两变量中的数，由用户输入；它们可以是浮点数；捕捉用户的输入错误，除数不为零的错误，程序结束输出“结束”提示。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "try:\n",
+    "    a=float(input('a：'))\n",
+    "    b=float(input('b：'))\n",
+    "    print(f\"{a/(a-b-1)}\")\n",
+    "    print(f\"{math.sqrt(a**2-b**2)}\"\")\n",
+    " \n",
+    "except_______ :\n",
+    "    print('小学没读好？除数能为0吗？')\n",
+    "except _____________:\n",
+    "    print('请使用浮点数，斜边必须大于直角边')\n",
+    "__________:\n",
+    "          print(\"结束\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}