diff --git a/Answer_Lab01-08.ipynb b/Answer_Lab01-08.ipynb
new file mode 100644
index 0000000..57faacb
--- /dev/null
+++ b/Answer_Lab01-08.ipynb
@@ -0,0 +1,1601 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b57930d5",
+   "metadata": {},
+   "source": [
+    "## 实践1 初识Python "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b734eb0e",
+   "metadata": {},
+   "source": [
+    "（1）使用for语句改写下面程序，实现一下输出。\n",
+    "重要的事情说三遍\n",
+    "Hello Python World!\n",
+    "Hello Python World!\n",
+    "Hello Python World!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "beba0cb8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hello Python World!\n",
+      "Hello Python World!\n",
+      "Hello Python World!\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i in range(3):\n",
+    "    print(\"Hello Python World!\")"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "13c70a11",
+   "metadata": {},
+   "source": [
+    "（2）改写程序Fl1-2，实现求任意两个整数的乘积并输出\n",
+    "  要求：增加变量a和b，表示乘法运算的2个操作数，改写乘法的表达式。\n",
+    "        a变量和b变量的值由用户输入，输入两个整数。\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "1c59a977",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "a=10\n",
+      "b=50\n",
+      "500\n"
+     ]
+    }
+   ],
+   "source": [
+    "a=int(input(\"a=\"))\n",
+    "b=int(input(\"b=\"))\n",
+    "s =a* b\n",
+    "print(s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ef6056cb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "（3）改写程序FL1-3.py，实现输入一个月份，输出对应的英文缩写"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "e06373bd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "month=7\n",
+      "Jul\n"
+     ]
+    }
+   ],
+   "source": [
+    "months=\"MonFebMarAprMayJunJulAugSepOctNovDec\" \n",
+    "n = int(input(\"month=\"))\n",
+    "monthAbbrev = months[(n-1)*3:(n-1)*3+3]\n",
+    "print(monthAbbrev)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "053250c7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "(4)改写程序FL1-3.py，实现顺序输出12月份对应的英文缩写。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "dee2c400",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mon\n",
+      "Feb\n",
+      "Mar\n",
+      "Apr\n",
+      "May\n",
+      "Jun\n",
+      "Jul\n",
+      "Aug\n",
+      "Sep\n",
+      "Oct\n",
+      "Nov\n",
+      "Dec\n"
+     ]
+    }
+   ],
+   "source": [
+    "months=\"MonFebMarAprMayJunJulAugSepOctNovDec\" \n",
+    "for n in range(1,13):\n",
+    "    monthAbbrev = months[(n-1)*3:(n-1)*3+3]\n",
+    "    print(monthAbbrev)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9bf6e1a2",
+   "metadata": {},
+   "source": [
+    "## 实践2 Python 基本语法"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b0d77cb9",
+   "metadata": {},
+   "source": [
+    "1.输入以下表达式并查看结果。\n",
+    "\n",
+    "①23+3 ②23>3 ③'23'+'3' ④23/3 ⑤ 23//3⑥23%3⑦23**3   \n",
+    "问题：\n",
+    "表达式结果为整数类型有哪些？  ①⑤ ⑥⑦\n",
+    "表达式结果为浮点数类型有哪些？④\n",
+    "表达式结果为字符串类型有哪些？ ③                                \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dffd4966",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7e403538",
+   "metadata": {},
+   "source": [
+    "2.执行完下面数值表达式语句后，变量a~k的值分别是多少？\n",
+    "```python  \n",
+    "a=5\n",
+    "b=2\n",
+    "a*=b\n",
+    "b+=a\n",
+    "a,b=b,a\n",
+    "c=6\n",
+    "d= c%2+(c+1)%2\n",
+    "e =2.5\n",
+    "f=3.5\n",
+    "g=(a+b)%3+int(f)//int(e)\n",
+    "h=float(a+b)%3+int(f)//int(e)\n",
+    "i=(a+b)/3+f%e\n",
+    "j=a<b and c<d\n",
+    "k=not j and True\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "e1cb878e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(12, 10)"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = 5\n",
+    "b = 2\n",
+    "a *= b\n",
+    "b += a\n",
+    "a,b = b,a\n",
+    "a,b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "13189923",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "c = 6\n",
+    "d = c%2+(c+1)%2\n",
+    "d"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "66f1c8fa",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "e = 2.5\n",
+    "f = 3.5\n",
+    "g = (a+b)%3+int(f)//int(e)\n",
+    "g"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "57c7310b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.0"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "h = float(a+b)%3+int(f)//int(e)\n",
+    "h"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "1cef28c2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "8.333333333333332"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "i = (a+b)/3+f%e\n",
+    "i"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "0a1c57f7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "j = a<b and c<d\n",
+    "j"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "24808a29",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "k = not j and True\n",
+    "k\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a209dc6",
+   "metadata": {},
+   "source": [
+    "2.条件表达式  \n",
+    "假设执行了如下语句  \n",
+    "x=384    \n",
+    "a,b=2.56769, 2.56789  \n",
+    "写出下面条件判断语句，并测试结果。  \n",
+    "（1）判断x是否是奇数；  \n",
+    "（2）判断x是否能被3和5整除；  \n",
+    "（3）判断x是否能被3或5整除；  \n",
+    "（4）判断b与a的差值不超过0.0001。  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "cd9006c5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x=384    \n",
+    "a,b=2.56769, 2.56789  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "1a26f065",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#判断x是否是奇数\n",
+    "x % 2 == 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "2d1939ce",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#判断x是否能被3和5整除\n",
+    "x % 3 == 0 and x % 5 == 0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "531a8143",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#判断x是否能被3或5整除\n",
+    "x % 3 == 0 or x % 5 == 0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "fdb75133",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#判断b与a的差值不超过0.0001\n",
+    "abs(b-a) < 0.0001"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "3267de25",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.00019999999999997797"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "b-a"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "308be02a",
+   "metadata": {},
+   "source": [
+    "## 实践3 模块和函数 小试身手\n",
+    "1.使用math模块的数学函数"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6959d040",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e3527c70",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "math.sqrt(22+33)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0f526d5e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "math.log10(100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3769e583",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "math.exp(2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c6c5f3d7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "math.fmod(4,3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "420d3c4a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "math.sin(2*math.pi)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0a2b8a61",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "math.gcd(12,9)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "25204f11",
+   "metadata": {},
+   "source": [
+    "\n",
+    "2. 自定义求矩形面积的函数"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "87448f3f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#定义一个函数getArea(length,width)，计算长为length,宽为width的矩形面积。  \n",
+    "def getArea(length,width):\n",
+    "    return length*width"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "03b2e0df",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10.0"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "getArea(2.5,4.0)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "6ee9638f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "length=25.7\n",
+      "width=55.8\n",
+      "面积： 1434.06\n"
+     ]
+    }
+   ],
+   "source": [
+    "l,w = float(input(\"length=\")),float(input(\"width=\"))\n",
+    "print(\"面积：\",getArea(l,w))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c2f98f2a",
+   "metadata": {},
+   "source": [
+    "## 实践4 逻辑判段和选择结构 小试身手\n",
+    "1.编写程序：输入半径r，输出以r为半径的圆的面积。使用math库中的数学函数math.pi，如果输入数据为负数，输出\"ERROR\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "c6a5a039",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "r=-2.9\n",
+      "ERROR\n"
+     ]
+    }
+   ],
+   "source": [
+    "# math.pi的导入方法是在程序开头加上下面一行代码，程序中用 math.pi 表示 pi\n",
+    "import math\n",
+    "r = float(input(\"r=\"))\n",
+    "if r < 0:\n",
+    "    print(\"ERROR\")\n",
+    "else:\n",
+    "    print(math.pi*r*r)"
+   ]
+  },
+  {
+   "attachments": {
+    "image-2.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "id": "9b2b18f1",
+   "metadata": {},
+   "source": [
+    "2.改错题，程序实现的功能是按照下面的分段函数，对输入的整数x，输出对应的y值。对于超出范围的整数x，输出“ERROR”。\n",
+    "\n",
+    "![image-2.png](attachment:image-2.png)\n",
+    "下面的程序有三处错误，请找出并修改，试程序能正常运行。  \n",
+    "测试用例：  \n",
+    "输入：12    输出：ERROR  \n",
+    "输入： 6    输出：36  \n",
+    "输入：-1    输出：5  \n",
+    "输入： 5    输出：19  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "9798710d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "12\n",
+      "ERROR\n"
+     ]
+    }
+   ],
+   "source": [
+    "x = int(input())      #1.\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 :     #2\n",
+    "        y = 6 * x      \n",
+    "    print(y)    #3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "41287cfc",
+   "metadata": {},
+   "source": [
+    "## 实践5  小试身手\n",
+    "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": 5,
+   "id": "1cf553c3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4\n",
+      "人生苦短"
+     ]
+    }
+   ],
+   "source": [
+    "n=int(input())\n",
+    "s = '人生苦短我用python'\n",
+    "i=0\n",
+    "while( i<n    ):\n",
+    "    print(s[i],end=\"\")\n",
+    "    i=i+1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fbebc9c1",
+   "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": 6,
+   "id": "9f56dba0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4\n",
+      "人生苦短"
+     ]
+    }
+   ],
+   "source": [
+    "n=int(input())\n",
+    "s = '人生苦短我用python'\n",
+    "for ch in s[:n]:\n",
+    "    print(ch,end=\"\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c48066c9",
+   "metadata": {},
+   "source": [
+    "## 实践6 小试身手"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "14253686",
+   "metadata": {},
+   "source": [
+    "编写程序以完成如下两个表达式的计算  \n",
+    "a/(a-b-1)  \n",
+    "a**b  \n",
+    "要求：a、b两变量中的数，由用户输入；它们可以是浮点数；捕捉用户的输入错误，除数不为零的错误，程序结束输出“结束”提示。  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "9c0d6de2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "a：10\n",
+      "b：0\n",
+      "1.1111111111111112\n",
+      "1.0\n",
+      "结束\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    a=float(input('a：'))\n",
+    "    b=float(input('b：'))\n",
+    "    print(f\"{a/(a-b-1)}\")\n",
+    "    print(f\"{a**b}\")\n",
+    "except ZeroDivisionError:\n",
+    "    print('小学没读好？除数能为0吗？')\n",
+    "except ValueError :\n",
+    "    print('请输入数值')\n",
+    "finally:\n",
+    "          print(\"结束\")   "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d4d73557",
+   "metadata": {},
+   "source": [
+    "## 实践7 "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38eb4369",
+   "metadata": {},
+   "source": [
+    "### 试一试"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f6f2c8fa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#随机生成100内的10个整数\n",
+    "random.sample(range(1,101),10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "369423a8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#随机生成0到100内的1个奇数\n",
+    "random.randrange(1,100,2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b0803ac4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#从字符串'abcdefghijklmnopqrstuvwxyz'中随机抽取5个字符\n",
+    "random.sample('abcdefghijklmnopqrstuvwxyz',5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f5ccb353",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#随机选取列表['周畅','吴用恭','郑皓侃','王边丞']中的一个姓名\n",
+    "random.choice(['周畅','吴用恭','郑皓侃','王边丞'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "79a97bbf",
+   "metadata": {},
+   "source": [
+    "### 小试身手\n",
+    "1.编写程序：输入一个正整数 n, 计算并输出数列1、-1/2、2/3、-3/5、4/8、-5/12...的前n项和。 要求以浮点数形式输出数列前n项的和。  \n",
+    "测试用例如下：  \n",
+    "输入：2，输出：0.5  \n",
+    "输入：10，输出：0.7284179117871402\n",
+    "输入：1，输出：1.0  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "4b89315b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "10\n",
+      "0.7284179117871402\n"
+     ]
+    }
+   ],
+   "source": [
+    "n = int(input())\n",
+    "a,b = 1,2\n",
+    "flag = -1\n",
+    "sum = 1.0\n",
+    "for i in range(1,n):\n",
+    "    sum = sum + flag * a / b\n",
+    "    a,b = i + 1 ,a + b\n",
+    "    flag = -flag\n",
+    "print(sum)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "50055d96",
+   "metadata": {},
+   "source": [
+    "### 小试身手  \n",
+    "2.输入一组任意浮点数，请分别统计正数和负数的平均值。输入“quit”结束。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "43755a16",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "请输入一个浮点数：-2.56\n",
+      "请输入一个浮点数：-68.93\n",
+      "请输入一个浮点数：176.5\n",
+      "请输入一个浮点数：0\n",
+      "请输入一个浮点数：-3.22\n",
+      "请输入一个浮点数：0\n",
+      "请输入一个浮点数：35.88\n",
+      "请输入一个浮点数：quit\n",
+      "2个正数的平均值为：106.19 \n",
+      "3个负数的平均值为：-24.90 \n"
+     ]
+    }
+   ],
+   "source": [
+    "s1,s2=0,0\n",
+    "n1,n2=0,0\n",
+    "x=input(\"请输入一个浮点数：\")\n",
+    "while x!=\"quit\":\n",
+    "        x=float(x)\n",
+    "        if x >0:\n",
+    "            s1=s1+x\n",
+    "            n1=n1+1\n",
+    "        elif x<0:\n",
+    "            s2=s2+x\n",
+    "            n2=n2+1\n",
+    "        x=input(\"请输入一个浮点数：\")\n",
+    "print(\"{}个正数的平均值为：{:.2f} \".format(n1,s1/n1))\n",
+    "print(\"{}个负数的平均值为：{:.2f} \".format(n2,s2/n2))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3822336a",
+   "metadata": {},
+   "source": [
+    "3.使用random模块函数，随机生成100个值为【-1000，1000】之间的整数，分别统计其中能被3或7整除的数的个数。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "28fc250e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "511\t720\t-717\t-468\t780\t-198\t\n",
+      "能被3或7整除的数有6个，均值为104.66666666666667\n"
+     ]
+    }
+   ],
+   "source": [
+    "from random import randint \n",
+    "n = 0\n",
+    "s = 0\n",
+    "for i in range(20):\n",
+    "    x = randint(-1000,1000)\n",
+    "    if x%3 == 0  or x%7 == 0:\n",
+    "        print(x,end=\"\\t\")\n",
+    "        s += x\n",
+    "        n = n+1\n",
+    "print(f\"\\n能被3或7整除的数有{n}个，均值为{s/n}\")\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "f966e03c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-63"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "s\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "85940ae3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "4.：输入一组数，寻找最大值，需要同时输出，最大值的第几个数，如何修改程序？"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "117cd534",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "请输入一个浮点数：9.34\n",
+      "请输入一个浮点数：-0.25\n",
+      "请输入一个浮点数：190.382\n",
+      "请输入一个浮点数：88.27\n",
+      "请输入一个浮点数：-82.99\n",
+      "请输入一个浮点数：over\n",
+      "最大值是第3个数190.382\n"
+     ]
+    }
+   ],
+   "source": [
+    "maxnum=input(\"请输入一个浮点数：\")\n",
+    "maxindex=1\n",
+    "n=1\n",
+    "if maxnum != \"over\":\n",
+    "    maxnum=float(maxnum)\n",
+    "   \n",
+    "    x=input(\"请输入一个浮点数：\")\n",
+    "    n=2\n",
+    "    while x!=\"over\":\n",
+    "            x=float(x)\n",
+    "            if x > maxnum:\n",
+    "                    maxnum=x\n",
+    "                    maxindex=n\n",
+    "                    \n",
+    "            x=input(\"请输入一个浮点数：\")\n",
+    "            n=n+1\n",
+    "\n",
+    "    print(f\"最大值是第{maxindex}个数{maxnum}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "72db5e68",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "打出所有的水仙花数（水仙花数是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身）"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "018fad85",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "153\t370\t371\t407\t"
+     ]
+    }
+   ],
+   "source": [
+    "for a in range(1,10):\n",
+    "    for b in range(0,10):\n",
+    "        for c in range(0,10):\n",
+    "            num=a*100+b*10+c\n",
+    "            if a**3+b**3+c**3 == num:\n",
+    "                print(num,end=\"\\t\")\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b4f0c3fa",
+   "metadata": {},
+   "source": [
+    "##  实践8"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "93362a6e",
+   "metadata": {},
+   "source": [
+    "### 试一试\n",
+    "\n",
+    "利用s1、s2和字符串操作，写出能产生下列结果的表达式。\n",
+    "s1='programming'\n",
+    "s2='language'\n",
+    "（1）\"program\"                          \n",
+    "（2）\"prolan\"                           \t\n",
+    "（3）\"amamam\"\n",
+    "（4）\"   programming  language  \"\n",
+    "（5）\"progr@mming l@ngu@ge\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "0c326a7d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s1='programming'\n",
+    "s2='language'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "57e9ecb1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'program'"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#（1）\"program\"\n",
+    "s1[:7]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "f3665008",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'prolan'"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#（2）\"prolan\" \n",
+    "s1[:3]+s2[:3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "e32b93e1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'amamam'"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#（3）\"amamam\"\n",
+    "s1[5:7]*3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "67c7c983",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'progr@mming l@ngu@ge'"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#（4）\"progr@mming l@ngu@ge\"\n",
+    "s1.replace(\"a\",\"@\")+\" \"+s2.replace(\"a\",\"@\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "7c06cdb5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Programming Language'"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#（5）'Programming Language'\n",
+    "s1.capitalize()+\" \"+s2.capitalize()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "111debcc",
+   "metadata": {},
+   "source": [
+    "### 试一试：\n",
+    "寻找一个源字符串s中的子串sub的所有位置。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "82a651ae",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "s=do not,for one repuls,forgo the purpose that you resolved to effort\n",
+      "sub=o\n",
+      "1\t4\t8\t11\t23\t26\t36\t46\t52\t59\t64\tover\n"
+     ]
+    }
+   ],
+   "source": [
+    "#方法一  经典while循环\n",
+    "s = input(\"s=\")\n",
+    "sub = input(\"sub=\")\n",
+    "start=0\n",
+    "index=s.find(sub,start)\n",
+    "while index != -1:\n",
+    "    print(index,end=\"\\t\")\n",
+    "    start = index+1\n",
+    "    index=s.find(sub,start)\n",
+    "print(\"over\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "728ce498",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#方法二 while True 算法模式\n",
+    "s = input(\"s=\")\n",
+    "sub = input(\"sub=\")\n",
+    "start=0\n",
+    "\n",
+    "while True:\n",
+    "    index=s.find(sub,start)\n",
+    "    if index == -1:\n",
+    "        break\n",
+    "    print(index,end=\"\\t\")\n",
+    "    start = index+1\n",
+    "    \n",
+    "print(\"over\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e35a0a52",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "方法三 异常处理算法模式\n",
+    "s = input(\"s=\")\n",
+    "sub = input(\"sub=\")\n",
+    "start = 0\n",
+    "while True:\n",
+    "    try:\n",
+    "        index=s.index(sub,start)\n",
+    "        print(index,end=\"\\t\")\n",
+    "        start=index+1\n",
+    "    except ValueError:\n",
+    "        print('over')\n",
+    "        break\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "42ccd924",
+   "metadata": {},
+   "source": [
+    "### 小试身手  \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f89f066b",
+   "metadata": {},
+   "source": [
+    "（1）编写程序 实现二进制IP地址转为十进制IP地址。  \n",
+    "一个IP地址是由四个字节（每个字节8个位）的二进制码组成。输入一个合法的二进制表示的IP地址，请将其转换为十进制格式表示的IP地址输出（不考虑异常输入数据）。  \n",
+    "运行示例：  \n",
+    "input:11001100100101000001010101110010  \n",
+    "output:204.148.21.114  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "a284705c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "11001100100101000001010101110010\n",
+      "204.148.21.114\n"
+     ]
+    }
+   ],
+   "source": [
+    "ip2=input()\n",
+    "ip10=\"\"\n",
+    "start=0\n",
+    "for i in range(4):\n",
+    "    x=int(ip2[start:start+8],2)\n",
+    "    ip10+=str(x)+\".\"\n",
+    "    start+=8\n",
+    "print(ip10[:-1])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "5ec84a36",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "11001100100101000001010101110010\n",
+      "204.148.21.114\n"
+     ]
+    }
+   ],
+   "source": [
+    "ip2=input()\n",
+    "print(str(int(ip2[0:8],2))+\".\"+str(int(ip2[8:16],2))+\".\"+str(int(ip2[16:24],2))+\".\"+str(int(ip2[24:],2)))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "be7b2b8c",
+   "metadata": {},
+   "source": [
+    "（2）编写程序 随机产生50个-1000~1000之间的整数，输出其中逆序数大于原数据的整数并统计个数。  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "d7ce4f17",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "687 -564 -662 -873 519 367 -625 375 436 -981 -742 -231 -671 -382 -32 -30 -958 -920 -520 -97 -350 69 29 \n",
+      "共23个数\n"
+     ]
+    }
+   ],
+   "source": [
+    "from random import randint\n",
+    "n=0\n",
+    "for i in range(50):\n",
+    "    x = randint(-1000,1000)\n",
+    "    if x>0:\n",
+    "        y = int(str(x)[::-1])\n",
+    "    else:\n",
+    "        y = int(str(x)[:0:-1])*-1\n",
+    "    if y>x:\n",
+    "        print(x,end=\" \")\n",
+    "        n=n+1\n",
+    "print(f\"\\n共{n}个数\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "531bc39c",
+   "metadata": {},
+   "source": [
+    "(3)编写程序 实现电文加密  \n",
+    "有一行电文，已按如下规律译成密码：  \n",
+    "A-->Z a-->z  \n",
+    "B-->Y b-->y  \n",
+    "C-->X c-->x  \n",
+    " ...... ......  \n",
+    "即第一个字母变成第26个字母，第i个字母变成第（26-i+1)个字母，非字母字符不变。要求根据密码译回原文，并输出。  \n",
+    "\n",
+    "运行示例  \n",
+    "input：ABC123abc   \n",
+    "output：ZYX123zyx \n",
+    "\n",
+    "\n",
+    "input：Life is like an ice cream, enjoy it before it melts.  \n",
+    "output：Oruv rh orpv zm rxv xivzn, vmqlb rg yvuliv rg nvogh.  \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "8e3012c9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Life is like an ice cream, enjoy it before it melts.\n",
+      "Oruv rh orpv zm rxv xivzn, vmqlb rg yvuliv rg nvogh.\n"
+     ]
+    }
+   ],
+   "source": [
+    "plaintext = input()\n",
+    "ciphertext = ''\n",
+    "for ch in plaintext:\n",
+    "    if ch.isupper():\n",
+    "        ciphertext += chr(ord(\"A\")+26-(ord(ch)-ord(\"A\"))-1)\n",
+    "    elif ch.islower():\n",
+    "         ciphertext += chr(ord(\"a\")+26-(ord(ch)-ord(\"a\"))-1)\n",
+    "    else:\n",
+    "        ciphertext = ciphertext + ch\n",
+    "print(ciphertext)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "345f93b6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Life is like an ice cream, enjoy it before it melts.\n",
+      "Oruv rh orpv zm rxv xivzn, vmqlb rg yvuliv rg nvogh.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import string \n",
+    "\n",
+    "plaintext = input()\n",
+    "ciphertext = ''\n",
+    "lower = string.ascii_lowercase\n",
+    "upper = string.ascii_uppercase \n",
+    "for ch in plaintext:\n",
+    "    if ch in  low:\n",
+    "        ciphertext += low[26-low.find(ch)-1]\n",
+    "    elif ch in upper:\n",
+    "        ciphertext += upper[26-upper.find(ch)-1]\n",
+    "    else:\n",
+    "        ciphertext = ciphertext + ch\n",
+    "print(ciphertext)      \n",
+    "        \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8c421a43",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1e224ed4",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.7.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Answer_Lab09-13.ipynb b/Answer_Lab09-13.ipynb
new file mode 100644
index 0000000..3873ca6
--- /dev/null
+++ b/Answer_Lab09-13.ipynb
@@ -0,0 +1,962 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "2b789064",
+   "metadata": {},
+   "source": [
+    "# 实验9~实践12 参考答案"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e1fa4e6d",
+   "metadata": {},
+   "source": [
+    "## 实践9 元组和列表  \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d6b5ae4e",
+   "metadata": {},
+   "source": [
+    "### 小试身手1\n",
+    "(1)\t已知列表 L1 和L2，由 L1 和 L2 构造L3，并回答问题。  \n",
+    "```python\n",
+    "    >>> L1=[1,2,3,4,5]\n",
+    "    >>> L2=[\"one\",\"two\",\"three\",\"four\",\"five\"]\n",
+    "    >>> L3=[[L1[1],L2[1]],[L1[2],L2[2]],[L1[3],L2[3]]]\n",
+    "L3 的值是__________\n",
+    "L3[1][1]的值是__________\n",
+    "执行 L4=L3.pop(2)后，列表L3的值是__________，L4的值是__________。\n",
+    "再执行L3.extend(L4)，列表L3的值是__________。\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "ee0db3a0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "L1=[1,2,3,4,5]\n",
+    "L2=[\"one\",\"two\",\"three\",\"four\",\"five\"]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "61ec7df3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[2, 'two'], [3, 'three'], [4, 'four']]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "L3=[[L1[1],L2[1]],[L1[2],L2[2]],[L1[3],L2[3]]]\n",
+    "L3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "873f2572",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'three'"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "L3[1][1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "d3ca6442",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[4, 'four']"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "L4=L3.pop(2)\n",
+    "L4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "7910a864",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[2, 'two'], [3, 'three'], 4, 'four']"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "L3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "f2a4aaa7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[2, 'two'], [3, 'three'], 4, 'four']"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "L3.extend(L4)\n",
+    "L3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a6e368db",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "de8197bc",
+   "metadata": {},
+   "source": [
+    "(2)假设执行了如下语句\n",
+    "```python\n",
+    ">>> s1=[0,1,2,3,4,5,6]\n",
+    ">>> s2=['SUN','MON','TUE','WED','THU','FRI','SAT']\n",
+    "利用 s1、s2 和列表操作，创建下列结果的序列对象。\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "d985454f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s1=[0,1,2,3,4,5,6]\n",
+    "s2=['SUN','MON','TUE','WED','THU','FRI','SAT']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "a5a002be",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'SUN|MON|TUE|WED|THU|FRI|SAT'"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#s3: 'SUN|MON|TUE|WED|THU|FRI|SAT'\n",
+    "s3=\"|\".join(s2)\n",
+    "s3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "f8bb4c02",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[3, 4, 3, 4, 3, 4]"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#s4:[3,4,3,4,3,4]\n",
+    "s4=s1[3:5]*3\n",
+    "s4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "bea9fa4d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[(0, 'SUN'), (1, 'MON'), (2, 'TUE'), (3, 'WED'), (4, 'THU'), (5, 'FRI'), (6, 'SAT')]\n"
+     ]
+    }
+   ],
+   "source": [
+    "#s5: [(0,'SUN'),(1,'MON'),(2,'TUE'),(3,'WED'),(4,'THU'),(5,'FRI'),(6,'SAT')]\n",
+    "s5=list(zip(s1,s2))\n",
+    "print(s5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b7e2a784",
+   "metadata": {},
+   "source": [
+    "## 小试身手2\n",
+    "### (1)合并列表  \n",
+    "使用随机函数randint()，建立两个长度为5的二维列表A和B。包含的数据如下：‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬\n",
+    "\n",
+    "A列表：包含子列表 [学号，p成绩，m成绩]，学号为从1开始递增的正整数，成绩为0-100之间的随机整数。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬\n",
+    "\n",
+    "B列表：包含子列表 [学号，q成绩]，学号为从1开始递增的正整数，成绩为0-100之间的随机整数‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬\n",
+    "\n",
+    "先需要将A,B两个列表数据进行合并，即将B列表中的‘q成绩’添加到A列表中的相同学号的子列表中。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬\n",
+    "\n",
+    "输入一个整数k，将B列表中的'q成绩'插入到A列表相同学号的子列表的k位置上。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬\n",
+    "\n",
+    "合并完成后，输出合并后的A列表。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬\n",
+    "\n",
+    "注意：为保证生成固定序列，本题需要使用同一个循环结构生成两个随机列表A和B，类似：\n",
+    "```python\n",
+    "for #######：\n",
+    "    #A列表添加 学号，p成绩，m成绩\n",
+    "    #B列表添加 学号，q成绩\n",
+    "运行示例：\n",
+    "A: [[1, 94, 58], [2, 6, 84], [3, 26, 42], [4, 39, 98], [5, 22, 18]]\n",
+    "B: [[1, 33], [2, 82], [3, 29], [4, 26], [5, 24]]\n",
+    "3\n",
+    "[[1, 94, 58, 33], [2, 6, 84, 82], [3, 26, 42, 29], [4, 39, 98, 26], [5, 22, 18, 24]]\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c4adadb0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random\n",
+    "a=[]\n",
+    "b=[]\n",
+    "\n",
+    "for i in range(1,6):     \n",
+    "    a.append([i,random.randint(0,100),random.randint(0,100)])     \n",
+    "    b.append([i,random.randint(0,100)])\n",
+    "print(\"A:\",a)\n",
+    "print(\"B:\",b)\n",
+    "p=int(input()) \n",
+    "for i in range(len(a)):\n",
+    "    a[i].insert(p,b[i][1]) \n",
+    "print(a)    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9dd4a7a",
+   "metadata": {},
+   "source": [
+    "### (2)成绩统计\n",
+    "输入用空格分隔的两个正整数n和m，表示后面要接收m个人的n门课的成绩的输入。\n",
+    "随后的m行，每行输入用空格分隔的n个成绩。题目保证m和n都在(0-100]之间。\n",
+    "请统计\n",
+    "（1）每门课的平均成绩。\n",
+    "（2）每个学生的平均成绩\n",
+    "（3）每门课的最高分"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "23a32ac5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "n=3\n",
+      "m=5\n",
+      "63 87 76\n",
+      "98 92 90\n",
+      "86 83 82\n",
+      "69 98 71\n",
+      "77 74 92\n",
+      "[[63, 87, 76], [98, 92, 90], [86, 83, 82], [69, 98, 71], [77, 74, 92]]\n",
+      "每个学生的平均成绩: [75.33, 93.33, 83.67, 79.33, 81.0]\n",
+      "每门课的平均成绩: [78.6, 86.8, 82.2]\n",
+      "每门课的最高分: [98, 98, 92]\n"
+     ]
+    }
+   ],
+   "source": [
+    "n,m = int(input(\"n=\")),int(input(\"m=\"))\n",
+    "Scores = []\n",
+    "for i in range(m):\n",
+    "    Scores.append([int(x) for x in input().split()])\n",
+    "print(Scores)\n",
+    "avgs=[]#每个学生的平均成绩\n",
+    "for stu in Scores:\n",
+    "    avgs.append(round(sum(stu)/len(stu),2))\n",
+    "print(\"每个学生的平均成绩:\",avgs)\n",
+    "\n",
+    "ksums=[0]*n #每门课的平均成绩\n",
+    "kmaxs=[0]*n #每门课的最高分\n",
+    "for stu in Scores:\n",
+    "    for i in range(n):\n",
+    "        ksums[i]+=stu[i]\n",
+    "        if stu[i]>kmaxs[i]:\n",
+    "            kmaxs[i] = stu[i]\n",
+    "kavgs = [ round(x/m,2) for x in ksums]\n",
+    "print(\"每门课的平均成绩:\",kavgs)\n",
+    "print(\"每门课的最高分:\",kmaxs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "84af1780",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5262941a",
+   "metadata": {},
+   "source": [
+    "## 实践10 集合和字典\n",
+    "小试身手1 （略）"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "471a3f13",
+   "metadata": {},
+   "source": [
+    "### 小试身手2\n",
+    "输入两个整数，在这两个整数组成的闭区间范围内生成100个随机整数，并统计出现数据的次数，按照生成随机数从小到大的顺序，每行输出一个生成的整数以及其出现的次数，以空格间隔。  \n",
+    "```python\n",
+    "例如：\n",
+    "输入：\n",
+    "3 5\n",
+    "输出：\n",
+    "3 36\n",
+    "4 39\n",
+    "5 25\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "c82977a4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3 5\n",
+      "3 36\n",
+      "4 39\n",
+      "5 25\n"
+     ]
+    }
+   ],
+   "source": [
+    "import random\n",
+    "dic = {}\n",
+    "m,n=map(int,input().split())\n",
+    "random.seed(10)\n",
+    "\n",
+    "for i in range (100):\n",
+    "    key = random.randint(m,n)\n",
+    "    if key in dic:\n",
+    "        dic[key] += 1\n",
+    "    else:\n",
+    "        dic[key] = 1\n",
+    "for i in sorted(dic.keys()):\n",
+    "    print('{} {}'.format(i,dic[i]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d5b06fc",
+   "metadata": {},
+   "source": [
+    "## 实践11 模块化程序设计  \n",
+    "1.完整程序，程序功能实现统计1000以内每100个整数中素数的个数。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "dcba82ab",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  1- 100 有26个素数\n",
+      "101- 200 有21个素数\n",
+      "201- 300 有16个素数\n",
+      "301- 400 有16个素数\n",
+      "401- 500 有17个素数\n",
+      "501- 600 有14个素数\n",
+      "601- 700 有16个素数\n",
+      "701- 800 有14个素数\n",
+      "801- 900 有15个素数\n",
+      "901-1000 有14个素数\n"
+     ]
+    }
+   ],
+   "source": [
+    "from math import sqrt\n",
+    "def isPrime(n):\n",
+    "        m=int(sqrt(n))\n",
+    "        for i in range(2,m+1):\n",
+    "                if n%i ==0:\n",
+    "                        return False\n",
+    "        return True\n",
+    "def countPrimes(start,end):\n",
+    "        c=0\n",
+    "        for n in range(start,end+1):\n",
+    "                if isPrime(n):\n",
+    "                        c=c+1\n",
+    "        return c \n",
+    "\n",
+    "#主程序\n",
+    "for start in range(1,1000,100):\n",
+    "        print(f\"{start:3d}-{start+99:4d} 有{countPrimes(start,start+99)}个素数\")\n",
+    "            "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e33847ab",
+   "metadata": {},
+   "source": [
+    " ## 3.斐波那契数列\n",
+    " ### (1) 单变量实现"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "efa91d0c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fib(n):\n",
+    "        if n<=2:\n",
+    "                return 1\n",
+    "        f1=f2=1\n",
+    "        while n>=3:\n",
+    "                f3=f1+f2\n",
+    "                f1,f2=f2,f3\n",
+    "                n=n-1\n",
+    "        return f3\n",
+    "\n",
+    "\n",
+    "n=int(input(\"n=\"))\n",
+    "print(fib(n))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4d0b3b92",
+   "metadata": {},
+   "source": [
+    "## (2) 列表实现"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "48aa767e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fib( n ):\n",
+    "        if n<=2:\n",
+    "                return 1\n",
+    "        FL=[1,1]\n",
+    "        i=2\n",
+    "        while i<n:\n",
+    "                FL.append(FL[i-1]+FL[i-2])\n",
+    "                i=i+1\n",
+    "        return FL[-1]                  \n",
+    "        \n",
+    "n=int(input(\"n=\"))\n",
+    "print(fib(n))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5dee8615",
+   "metadata": {},
+   "source": [
+    "## (3)  字典实现"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4cde2e34",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fib(n):           \n",
+    "    a = 0\n",
+    "    b = 1\n",
+    "    dic = {}               ## {} or dict()     \n",
+    "    for i in range(n):     ## range   \n",
+    "        dic[i]=a           ## a   \n",
+    "        a,b=b,a+b\n",
+    "        \n",
+    "    return dic               ## dic   \n",
+    "    \n",
+    "#调用函数生成斐波那契数列中的前20个斐波那契数\n",
+    "fibonac = fib(20)         ##   fib(20)   调用函数 \n",
+    "    print(fibonac[key], end=\",\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7494690d",
+   "metadata": {},
+   "source": [
+    "## (4)递归函数"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5da061f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def Fib(n):\n",
+    "        if n==1 or n==2 :\n",
+    "                return 1\n",
+    "        return Fib(n-1)+Fib(n-2)\n",
+    "\n",
+    "n=int(input(\"n=\"))\n",
+    "print(Fib(n))\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fdcc945d",
+   "metadata": {},
+   "source": [
+    "## (5) 优化的递归函数"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "46f27dea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "d_fib={1:1,2:1}\n",
+    "def Fib(n):\n",
+    "        if n in d_fib :\n",
+    "                return d_fib[n]\n",
+    "        m=Fib(n-1)+Fib(n-2)\n",
+    "        d_fib[n]= m\n",
+    "        return m\n",
+    "\n",
+    "n=int(input(\"n=\"))\n",
+    "print(Fib(n))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eecb1ba6",
+   "metadata": {},
+   "source": [
+    "## 实践12 再谈Python函数  \n",
+    "### 小试身手(1)  \n",
+    "阅读可变参数的vfunc函数，仿写milti函数实现返回所有参数的乘积"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "b4245d1d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "720"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def milti(*num):\n",
+    "    p=1\n",
+    "    for x in num:\n",
+    "        p=p*x\n",
+    "    return p\n",
+    "milti(1,2,3,4,5,6)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e2c1ee22",
+   "metadata": {},
+   "source": [
+    "### 小试身手(2)    \n",
+    "1.判断奇数  \n",
+    "判断奇数的函数lambda函数的定义和使用  \n",
+    "（1）编写一个函数isOdd，能够判断一个整数是否是奇数，返回True或False。  \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "af90b317",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "isodd = lambda x: x%2 == 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "519d41a6",
+   "metadata": {},
+   "source": [
+    "（2）请写出输入一个数x，调用isOdd函数判断x是否是奇数的程序段"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "b75e2c05",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "x=8\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "x = int(input(\"x=\"))\n",
+    "print(isodd(x))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71637790",
+   "metadata": {},
+   "source": [
+    "（3）请写出求50-100之间所有奇数的和的程序段,（使用isOdd实现奇数判断）。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "22543b83",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "s= 1875\n"
+     ]
+    }
+   ],
+   "source": [
+    "s=0\n",
+    "for x in range(50,100):\n",
+    "    if isodd(x):\n",
+    "       # print(x)\n",
+    "        s+=x\n",
+    "print(\"s=\",s)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3ad734be",
+   "metadata": {},
+   "source": [
+    "（4）请写出求50-100之间所有偶数的和的程序段（使用isOdd实现偶数判断）。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "23d97c6a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "s= 1950\n"
+     ]
+    }
+   ],
+   "source": [
+    "s=0\n",
+    "for x in range(50,101):\n",
+    "    if not isodd(x):\n",
+    "       # print(x)\n",
+    "        s+=x\n",
+    "print(\"s=\",s)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71f64423",
+   "metadata": {},
+   "source": [
+    "2.构造整数:求由任意个整数上的个位数构造的新整数并输出。  \n",
+    "具体要求  \n",
+    "（1）编写lambda函数getLastBit，该函数返回正整数number的个位数，例如正整数1234，则返回4。  \n",
+    "（2）编写可变参数的函数makeNumber，求任意个整数的个位数构成的一个新整数。  \n",
+    "（3）输出（45、81、673、938）4个数的个位数构成的新整数，得到的新的整数为：5138。请填空完整程序。  \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "2b89059b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "新整数是5138\n"
+     ]
+    }
+   ],
+   "source": [
+    "#定义lambda函数getLastBit返回一个数的个位数\n",
+    "getLastBit=lambda number:number%10\n",
+    "\n",
+    "#定义一个可变参数的函数makeNumber，求任意个整数的个位数构成的一个新整数\n",
+    "def makeNumber(*b):\n",
+    "        s=0\n",
+    "        for i in b:\n",
+    "                s=s*10+getLastBit(i)\n",
+    "        return s\n",
+    "\n",
+    "#输出（45、81、673、938）4个数的个位数构成的新整数。\n",
+    "\n",
+    "print(f\"新整数是{makeNumber(45,81,673,938)}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cf9617cc",
+   "metadata": {},
+   "source": [
+    "## 实践13 递归函数"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b26582d3",
+   "metadata": {},
+   "source": [
+    "### 小试身手"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0bff8c63",
+   "metadata": {},
+   "source": [
+    "1.使用递归求最大公约数"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0bd1eb79",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def gcd(m,n):\n",
+    "    if m%n == 0:\n",
+    "        return n\n",
+    "    else:\n",
+    "        return gcd(n,m%n)\n",
+    "print(gcd(15,25))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d8006798",
+   "metadata": {},
+   "source": [
+    "2.使用递归方法逆序输出一个整数中的数字"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "099d4634",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    " def reverseDisplay(value):\n",
+    "        if value>0:\n",
+    "            print(value%10,end=\"\")\n",
+    "            reverseDisplay(value//10)\n",
+    "        return"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "cc25a415",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "12345"
+     ]
+    }
+   ],
+   "source": [
+    "reverseDisplay(54321)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0e80ecad",
+   "metadata": {},
+   "source": [
+    "3.使用递归方法逆序输出一个字符串中的字母 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "a2ff79ad",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "edcba"
+     ]
+    }
+   ],
+   "source": [
+    "def reverseDisplay(s):\n",
+    "    if len(s)!=1:\n",
+    "        reverseDisplay(s[1:])\n",
+    "    print(s[0],end=\"\")\n",
+    "reverseDisplay(\"abcde\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fcc70358",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.7.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Lab11.ipynb b/Lab11.ipynb
new file mode 100644
index 0000000..cacc4cf
--- /dev/null
+++ b/Lab11.ipynb
@@ -0,0 +1,867 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 实践11 程序的模块化编程  \n",
+    "模块化设计同样是程序设计的重要思想。程序的模块化设计，简单地说就是程序的编写不是一开始就逐条编写计算机语句和指令，而是首先用主程序、函数等框架把软件的主要结构和流程描述出来，并定义和调试好各个框架之间的输入、输出链接关系。再逐个实现每个模块的内部功能。模块化编程的目的是为了降低程序复杂度，使程序设计、调试和维护等操作简单化。  \n",
+    "1.理解程序的模块化设计方法    \n",
+    "2.理解参数和返回值的意义  \n",
+    "3.理解函数的执行过程  \n",
+    "4.掌握功能模块设计和实现  \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. 画“工”字"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "【例4-2-1】用字符画一个“工”字。\n",
+    "程序的功能是输入一个n值，画出的“工”字由2根2n+1个“8”组成的横线和1根n个“8”组成的竖线构成。\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n=int(input(\"n=\"))\n",
+    "for i in range(2*n+1):\n",
+    "        print(\"8\",end=\"\")\n",
+    "print()\n",
+    "for i in range(n):  \n",
+    "        for j in range(n):\n",
+    "                print(\" \",end=\"\")\n",
+    "        print(\"8\")\n",
+    "for i in range(2*n+1):\n",
+    "        print(\"8\",end=\"\")\n",
+    "print()\n"
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "【例4-2-2】设计两个构件模块：画横线和画竖线，再设计一个图形模块：画“工”字。改写后的程序如下所示。\n",
+    "![image.png](attachment:image.png)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def hline(n):#画横线\n",
+    "        for i in range(2*n+1):\n",
+    "                print(\"8\",end=\"\")\n",
+    "        print()\n",
+    "def vline(n):#画竖线\n",
+    "        for i in range(n):\n",
+    "                for j in range(n):  \n",
+    "                        print(\" \",end=\"\")\n",
+    "                print(\"8\")\n",
+    "def figure(n):#画“工”字\n",
+    "        hline(n)\n",
+    "        vline(n)        \n",
+    "        hline(n)       \n",
+    "def draw():#画指定n值的“工”字\n",
+    "        n=int(input(\"n=\"))\n",
+    "        figure(n)\n",
+    "draw() #主程序启动       \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "【例4-2-3】在例4-2-2的hline函数、vline函数、figure函数增加参数ch，传递用户输入的字符。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def hline(n,ch):\n",
+    "        for i in range(2*n+1):\n",
+    "                print(ch,end=\"\")\n",
+    "        print()\n",
+    "def vline(n,ch):\n",
+    "        for i in range(n):\n",
+    "                for j in range(n):\n",
+    "                        print(\" \",end=\"\")\n",
+    "                print(ch)\n",
+    "def figure(n,ch):\n",
+    "        hline(n,ch)\n",
+    "        vline(n,ch)        \n",
+    "        hline(n,ch)\n",
+    "        \n",
+    "def draw():\n",
+    "        n=int(input(\"n=\"))\n",
+    "        ch=input(\"ch=\")\n",
+    "        figure(n,ch)\n",
+    "draw()        \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 程序的开发过程\n",
+    "\n",
+    "(1)自顶向下、逐步求精是分析问题的基本方法，具体的做法是把一个大任务分割成小的更容易控制的任务，再继续细分为更小的任务，直到所有的小任务都能很容易实现。\n",
+    "(2)自顶向下的设计是创建层次化的模块结构的过程，从程序实现和测试的角度看，最好从模块结构图的底层开始实现、运行、测试每一个函数，然后逐步上升，实现上层模块，自底向上直至主程序得到实现。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "【例4-2-3的程序框架结构】\n",
+    "def hline(n,ch):\n",
+    "        pass\n",
+    "def vline(n,ch):\n",
+    "        pass\n",
+    "def figure(n,ch):\n",
+    "        pass\n",
+    "def draw():\n",
+    "        pass\n",
+    "draw()       \n"
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 小试身手（1）\n",
+    "（1）修改例4-2-3的程序：如果程序要求当输入一个偶数，图形用*绘制，输入一个奇数，图形用@绘制，应该修改哪个函数？如何修改？\n",
+    "![image.png](attachment:image.png)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#【例4-2-3】\n",
+    "def hline(n,ch):\n",
+    "        for i in range(2*n+1):\n",
+    "                print(ch,end=\"\")\n",
+    "        print()\n",
+    "def vline(n,ch):\n",
+    "        for i in range(n):\n",
+    "                for j in range(n):\n",
+    "                        print(\" \",end=\"\")\n",
+    "                print(ch)\n",
+    "def figure(n,ch):\n",
+    "        hline(n,ch)\n",
+    "        vline(n,ch)        \n",
+    "        hline(n,ch)\n",
+    "        \n",
+    "def draw():\n",
+    "        n=int(input(\"n=\"))\n",
+    "        ch=input(\"ch=\")\n",
+    "        figure(n,ch)\n",
+    "draw()        "
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "（2）修改例4-2-3的程序：如果要输出下面图形，应该修改哪个函数？如何修改？\n",
+    "![image.png](attachment:image.png)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#【例4-2-3】\n",
+    "def hline(n,ch):\n",
+    "        for i in range(2*n+1):\n",
+    "                print(ch,end=\"\")\n",
+    "        print()\n",
+    "def vline(n,ch):\n",
+    "        for i in range(n):\n",
+    "                for j in range(n):\n",
+    "                        print(\" \",end=\"\")\n",
+    "                print(ch)\n",
+    "def figure(n,ch):\n",
+    "        hline(n,ch)\n",
+    "        vline(n,ch)        \n",
+    "        hline(n,ch)\n",
+    "        \n",
+    "def draw():\n",
+    "        n=int(input(\"n=\"))\n",
+    "        ch=input(\"ch=\")\n",
+    "        figure(n,ch)\n",
+    "draw()        "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2.素数问题"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "【4.3.1】 判断一个数n是不是素数"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "算法：\n",
+    "1 输入一个数n\n",
+    "2 i=2\n",
+    "3 循环当i<n\n",
+    "      3.1如果n能被i整除则跳出\n",
+    "      3.2 i=i+1\n",
+    "4 如果i==n    则输出n是素数\n",
+    "          否则输出n不是素数\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "说明：  \n",
+    "这个算法的循环结构有两个出口：一个是“循环当i<n”不满足条件；一个是“如果n能被i整除则跳出”；两个出口分别代表不同的结论。第一个出口结束循环，n是素数；第二个出口结束循环，n不是素数。  \n",
+    "两个出口都汇聚到算法的第4步。在此，如何要区分两种不同的情况？  \n",
+    "仔细观察程序循环结构的执行，结束循环时，i的值是不同的。循环正常结束，i的值是等于n；在循环体中如果n能被i整除，跳出循环，i的值在2到n-1之间。利用i值的不同可以区分n是不是素数。  \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n=int(input(\"n=\"))       \n",
+    "i=2\n",
+    "while i<n:\n",
+    "        if n%i==0 :\n",
+    "                break\n",
+    "        i=i+1\n",
+    "if i==n:\n",
+    "        print(n,\"是素数\")\n",
+    "else:\n",
+    "        print(n,\"不是素数\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "【例4-3-2】用for语句实现判断一个数n是不是素数"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#算法失败的示例\n",
+    "n=int(input(\"n=\"))       \n",
+    "for i in range(2,n):\n",
+    "        if n%i==0 :\n",
+    "                break\n",
+    "if i==n:\n",
+    "        print(n,\"是素数\")\n",
+    "else:\n",
+    "        print(n,\"不是素数\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "说明：  \n",
+    "本算法是根据i的终值来判断是否为素数。for语句实现的程序和while语句实现的程序的不同在于：for循环正常执行结束（即不从break跳出）时，i值是n-1，而while循环正常结束时i值是n。也就是说一个素数执行for循环结束后，i值为n-1。例如n=3，for语句迭代运行i=2，n%i==0不满足，不执行break语句，迭代结束退出for语句。\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#使用flag修正上例错误\n",
+    "n=int(input(\"n=\"))       \n",
+    "flag=True\n",
+    "for i in range(2,n):\n",
+    "        if n%i==0 :\n",
+    "                flag=False\n",
+    "                break\n",
+    "if flag:\n",
+    "        print(n,\"是素数\")\n",
+    "else:\n",
+    "        print(n,\"不是素数\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#使用 for...else 修正错误\n",
+    "n=int(input(\"n=\"))       \n",
+    "for i in range(2,n):\n",
+    "        if n%i==0 :\n",
+    "                print(n,\"不是素数\")\n",
+    "                break\n",
+    "else:\n",
+    "        print(n,\"是素数\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "【例4-3-3】模块化编程实现判断一个数n是不是素数"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#【函数代码】\n",
+    "def isPrime(n):\n",
+    "    if n<2:\n",
+    "        return False\n",
+    "    \n",
+    "    flag=True\n",
+    "    for i in range(2,n):\n",
+    "            if n%i==0 :                       \n",
+    "               flag=False\n",
+    "               break\n",
+    "    return flag\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#【函数优化代码】\n",
+    "def isPrime(n):\n",
+    "    if n<2:\n",
+    "        return False\n",
+    "    for i in range(2,n):\n",
+    "        if n%i==0 :\n",
+    "            return False\n",
+    "    return True\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#【函数优化代码】\n",
+    "from math import sqrt \n",
+    "def isPrime(n):\n",
+    "        if n<2:\n",
+    "                return False\n",
+    "        m=int(sqrt(n))\n",
+    "        for i in range(2,m+1):\n",
+    "            if n%i==0 :\n",
+    "                  return False\n",
+    "        return True\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    " #主程序代码\n",
+    "n=int(input(\"n=\"))\n",
+    "if isPrime(n):\n",
+    "        print(n,\"是素数\")\n",
+    "else:\n",
+    "        print(n,\"不是素数\")\n"
+   ]
+  },
+  {
+   "attachments": {
+    "image-2.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "【例4-3-4】求解【a,b】区间以内的孪生素数。  \n",
+    "孪生素数（twin prime number），指的是相差为2的两个素数，例如3和5。孪生素数有其特殊的规则，除了第一对孪生素数（3，5）之外，其他的孪生素数都可以写成（6k-1，6k+1）的形式。找一找有哪些是孪生素数。\n",
+    "![image-2.png](attachment:image-2.png)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "【例4-3-4框架结构代码】\n",
+    "def isPrime(n):# 判断n是否素数\n",
+    "        pass\n",
+    "def getPrimes(start,end):# 获取指定区间素数\n",
+    "        pass\n",
+    "def getTwinPrimes(L):# 求解孪生素数组\n",
+    "        pass                \n",
+    "def printTwinPrimes(L):# 输出孪生素数\n",
+    "        pass\n",
+    "def main():\n",
+    "        L=getPrimes(2,3000)\n",
+    "        TwinL=getTwinPrimes(L)\n",
+    "        printTwinPrimes(TwinL)\n",
+    "        \n",
+    "if __name__ == \"__main__\":\n",
+    "    main()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def getPrimes(start,end):\n",
+    "        L=[]\n",
+    "        for n in range(start,end+1):\n",
+    "                if isPrime(n):\n",
+    "                        L.append(n)\n",
+    "        return L\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def getTwinPrimes(L):\n",
+    "        TwinL=[]\n",
+    "        for i in range(len(L)-1):\n",
+    "                if L[i+1]-L[i]==2:\n",
+    "                        TwinL.append((L[i],L[i+1]))\n",
+    "        return TwinL\n",
+    "                        \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def printTwinPrimes(L):\n",
+    "        n=0\n",
+    "        for x in  L:\n",
+    "                print(\"({:4d},{:4d})\".format(x[0],x[1]),end=\"\\t\")\n",
+    "                n=n+1\n",
+    "                if n%5==0:\n",
+    "                        print()\n",
+    "                \n",
+    "        print(\"\\n共{}组孪生素数\".format(n))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#主程序"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "【例4-3-4完整代码】\n",
+    "\n",
+    "from math import sqrt\n",
+    "def isPrime(n):\n",
+    "        if n<2:\n",
+    "                return False\n",
+    "        m=int(sqrt(n))\n",
+    "        for i in range(2,m+1):\n",
+    "                if n%i ==0:\n",
+    "                        return False\n",
+    "        return True\n",
+    "\n",
+    "def getPrimes(start,end):\n",
+    "        L=[]\n",
+    "        for n in range(start,end+1):\n",
+    "                if isPrime(n):\n",
+    "                        L.append(n)\n",
+    "        return L\n",
+    "def getTwinPrimes(L):\n",
+    "        TwinL=[]\n",
+    "        for i in range(len(L)-1):\n",
+    "                if L[i+1]-L[i]==2:\n",
+    "                        TwinL.append((L[i],L[i+1]))\n",
+    "        return TwinL\n",
+    "                        \n",
+    "def printTwinPrimes(L):\n",
+    "        n=0\n",
+    "        for x in  L:\n",
+    "                print(\"({:4d},{:4d})\".format(x[0],x[1]),end=\"\\t\")\n",
+    "                n=n+1\n",
+    "                if n%5==0:\n",
+    "                        print()\n",
+    "                \n",
+    "        print(\"\\n共{}组孪生素数\".format(n))\n",
+    "def main():\n",
+    "        a,b=input(\"请输入区间范围a,b:\").split(\",\")\n",
+    "        a,b=int(a),int(b)\n",
+    "        L=getPrimes(a,b)\n",
+    "        print(\"【{},{}】之间的素数有{}个\".format(a,b,len(L)))\n",
+    "        TwinL=getTwinPrimes(L)\n",
+    "        printTwinPrimes(TwinL)\n",
+    "        \n",
+    "if __name__ == \"__main__\":\n",
+    "    main()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 小试身手"
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "1.完整程序，程序功能实现统计1000以内每100个整数中素数的个数。\n",
+    "![image.png](attachment:image.png)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "from math import sqrt\n",
+    "def isPrime(n):\n",
+    "        m=int(sqrt(n))\n",
+    "        for i in range(2,m+1):\n",
+    "                if n%i ==0:\n",
+    "                        return False\n",
+    "        return True\n",
+    "def countPrimes(start,end):\n",
+    "       ...\n",
+    "\n",
+    "#主程序\n",
+    "for start in range(1,1000,100):\n",
+    "        print(f\"{start:3d}-{start+99:4d} 有{___________________}个素数\")\n",
+    "            "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#  3.斐波那契数列\n",
+    "斐波那契数列（Fibonacci Sequence ），又称费氏数列、黄金分割数列。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## (1) 单变量实现"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "使用三个单变量 f1,f2,f3 ，表示每次计算需要的三个数。\n",
+    "\n",
+    "1.如果 n=1,2 返回 1\n",
+    "2.f1,f2 置初值 1\n",
+    "3.循环当 n 大于等于 3\n",
+    "    3.1 计算 f3=f1+f2\n",
+    "    3.2 f2=>f1,f3=>f2\n",
+    "    3.3 n 减一\n",
+    "4.返回 f3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fib (n):\n",
+    "    if n<=2:\n",
+    "        return 1\n",
+    "    _____(1)_____\n",
+    "    while n>=3:\n",
+    "        f3=_____(2)_____\n",
+    "        f1,f2=_____(3)_____\n",
+    "        n=_____(4)_____\n",
+    "    return _____(5)_____\n",
+    "n=int(input(\"n=\"))\n",
+    "print(fib(n))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## (2) 列表实现"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "使用列表 FL 存放费波那契数列 \n",
+    "\n",
+    "1.如果n=1,2 返回1\n",
+    "2.FL置初值[1,1]\n",
+    "3.下标 i 置初值 2 ，指向第三项\n",
+    "4.循环当 i 小于 n\n",
+    "    4.1 追加 FL[i-1]+ FL[i22] 到 FL\n",
+    "    4.2 i=i+1   \n",
+    "5.返回列表最后一项"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fib (n):\n",
+    "    if n<=2:\n",
+    "        return 1\n",
+    "    FL= _____(1)_____\n",
+    "    i=2\n",
+    "    while i<n:\n",
+    "        FL._____(2)_____\n",
+    "        i=i+1\n",
+    "        return _____(3)_____\n",
+    "    \n",
+    "n=int(input(\"n=\"))\n",
+    "print(fib(n))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## (3)  字典实现"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "使用字典存放费波那契数列\n",
+    "\n",
+    "1.a=0,b=1\n",
+    "2.创建空字典dic\n",
+    "3.循环i 从0到n-1 \n",
+    "    3.1 将键值对<i,a>添加到字典dic\n",
+    "    3.2 a为b，b为a和b之和\n",
+    "4.返回字典"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fib(n):\n",
+    "    a=0\n",
+    "    b=1\n",
+    "    dic=_____(1)_____    #定义字典\n",
+    "    for i in range(n):\n",
+    "        dic[i]=_____(2)_____    #把添加斐波那契数到字典\n",
+    "        a,b=b,a+b\n",
+    "    return _____(3)_____\n",
+    "\n",
+    "#调用函数生成斐波那契数列中的前20个斐波那契数\n",
+    "fibonac= _____(4)_____\n",
+    "for key in fibonac.keys():\n",
+    "    print(fibonac[key],end=\",\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## (4)递归函数\n",
+    "\n",
+    "递归函数是直接或者间接调用自身的函数。  \n",
+    "注意：可以学完实践13，再做以下两题"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "如果n等于1或2 则返回1\n",
+    "否则返回 Fib(n-1)+Fib(n-2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def Fib(n):\n",
+    "    if n==1 or n==2:\n",
+    "        return _____(1)_____\n",
+    "    _____(2)_____\n",
+    "    return m\n",
+    "n=int(input(\"n=\"))\n",
+    "print(Fib(n))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## (5) 优化的递归函数"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "定义一个全局字典变量d_fib 保存费波那契数列系数\n",
+    "\n",
+    "如果 n 存在在字典关键字中\n",
+    "  则   \n",
+    "     1.1 返回字典值   \n",
+    "  否则  \n",
+    "     1.2 计算递归公式获得第 n 项费波那契数列系数 m\n",
+    "     1.3 将新的键值对追加到字典\n",
+    "     1.4 返回 m"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "d_fib=_____(1)_____\n",
+    "def Fib(n):\n",
+    "    if n in d_fib:\n",
+    "        return _____(2)_____\n",
+    "    m= _____(3)_____\n",
+    "    d_fib[n]=_____(4)_____\n",
+    "    return m\n",
+    "\n",
+    "n=int(input(\"n=\"))\n",
+    "print(Fib(n))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.7.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Lab12.ipynb b/Lab12.ipynb
new file mode 100644
index 0000000..bfe5b86
--- /dev/null
+++ b/Lab12.ipynb
@@ -0,0 +1,988 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 实践12 再谈python函数\n",
+    "\n",
+    "1. 理解函数定义四要素：函数名、参数表、函数体和返回值，本章对每一个部分都进行了更深入的说明，尤其是一些特殊的用法；\n",
+    "2. 理解 函数定义内外是两个不同的“**作用域**（*scope*）”，区分出全局变量和局部变量，需要充分理解其运作原理；\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "我们已经见过不少函数，也自己写过一些函数。我们已经理解函数的概念来自代数：从**输入参数**出发，**计算**出函数的**返回值**；我们也知道可以用 `def foo():` 来定义函数。其实函数的定义非常复杂，我们不太能够在第一次介绍时就讲清楚，所以之前我们就采取“先引入用起来”的方法，这也是一种知识上的“提前引用”。\n",
+    "\n",
+    "本章将围绕函数几个重要的要素深入看看。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1. 为函数命名"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "哪怕一个函数内部什么都不干，它也得有个名字，然后名字后面要加上圆括号 `()`，以明示它是个函数，而不是某个变量。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def do_nothing():\n",
+    "    pass\n",
+    "\n",
+    "do_nothing()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "这就是个“什么也不干”的函数，关键字 `pass` 就是什么也不干的意思。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "给函数命名（给变量命名也一样）需要遵循的一些规则如下：\n",
+    "* 首先，名称不能以数字开头，能用在名称开头的只有大小写字母和下划线 `_`；\n",
+    "* 其次，名称中不能有空格，如果一个名字里有好几个词汇，可以用下划线来分割（`do_nothing`），也可以用所谓 *Camel Case* 风格（*doNothing*），习惯上更推荐使用下划线；\n",
+    "* 最后，绝对不能与 Python 语言的**关键字**（*keyword*）重复。\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "在程序里给变量、函数命名是个挺重要的事情，影响到程序的可读性，就像小说的语言，最好能有一种流畅清晰、又始终一致的**风格**（*style*）。为了让全世界的 Python 程序员都有相对一致的风格，Python 社区有专门的一套建议规范，放在专门维护 Python 语言特性的社区 [PEP](https://www.python.org/dev/peps/) 上：\n",
+    "\n",
+    "* [PEP 8 -- Style Guide for Python Code: Naming Conventions](https://www.python.org/dev/peps/pep-0008/#naming-conventions)\n",
+    "\n",
+    "> PEP，是 *Python enhancement proposal* 的缩写，每当有重要的语言特性新需求新想法，就放在这里，经过广大 Python 用户和开发者的讨论完善，在某个版本放进 Python 中。很多 PEP 早已从 *proposal* 毕业变成官方特性，但也还在这里保留着。PEP 8 就是一个古老的 *proposal*，现在已为大多数 Python 用户采纳。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2. 没有、一个和多个参数"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "函数可以没有参数，也可以有一个或者多个参数。\n",
+    "\n",
+    "没有参数就意味着，这个函数执行不依赖于输入，比如我们定义一个函数来在程序结束时打印一句退出提示："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Program exits. Bye.\n"
+     ]
+    }
+   ],
+   "source": [
+    "def exit_info():\n",
+    "    print('Program exits. Bye.')\n",
+    "    \n",
+    "exit_info()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "注意即使没有参数，无论定义还是调用时，函数名后面的括号都是不可省略的，这是函数身份的标志。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "函数也可以有多个参数，调用时输入参数的值是严格按照参数的顺序去匹配的。比如我们写一个函数输出某年到某年之间的所有闰年："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2000\n",
+      "2004\n",
+      "2008\n",
+      "2012\n",
+      "2016\n"
+     ]
+    }
+   ],
+   "source": [
+    "def leap_years(begin, end):\n",
+    "    year = begin\n",
+    "    while year < end:\n",
+    "        if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:\n",
+    "            print(year)\n",
+    "        year += 1\n",
+    "        \n",
+    "leap_years(2000, 2020)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "当我们调用 `leap_years(2000, 2020)` 时，输入两个参数值 2000 和 2020，按照顺序匹配函数定义 `leap_years(begin, end)`，于是 `begin = 2000` `end = 2020`。所以参数的顺序是不能搞错的，有些函数参数很多，要是开发过程中还调整过顺序的话，那简直就是灾难，所以一般情况下还是保持函数参数不要乱动为好。\n",
+    "\n",
+    "顺便说一句，判断闰年的算法虽然不难，但要写的简洁也不容易。建议你可以先自己思考和实现一遍，然后尝试搞清楚为啥上面代码里的那行 `if` 是对的。实际上闰年的判断有很多正确的写法，你应该尝试写出自己的版本并确认它的正确性。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3. 没有、一个和多个返回值"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "和参数一样，Python 的函数可以没有返回值，也可以有一个或者多个返回值。\n",
+    "\n",
+    "上面的 `exit_info` 和 `leap_year` 也是没有返回值的例子，它们的效果都通过 `print` 函数来体现。实际上没有返回语句的函数，等价于在其最后有一句 `return None`，表示函数返回了一个空值 `None`，`None` 在 Python 中是一个合法的值，表示什么都没有，它在逻辑上等价于 `False`："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bool(None)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "所以即使没有返回值的函数，也可以用在 `if` 后面做逻辑表达式，不过我们并不推荐这么做，因为可读性很差。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "大部分情况下函数是有返回值的，因为绝大部分情况下函数的作用都是做“数据处理”，从输入出发得到输出。\n",
+    "\n",
+    "一般情况下函数都只有一个返回值，我们已经见过不少例子；但 Python 也允许多返回值，比如我们想用一个函数来计算两个整数相除的商和余数，可以这么写："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "8 2\n"
+     ]
+    }
+   ],
+   "source": [
+    "def idiv(a, b):\n",
+    "    quotient = a // b\n",
+    "    remainder = a % b\n",
+    "    return quotient, remainder\n",
+    "\n",
+    "q, r = idiv(50, 6)\n",
+    "print(q, r)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "和多参数的情况类似，多返回值的情况下，赋值也是按照顺序匹配的，上面的代码中赋值语句左边的 `q` 匹配到第一个返回值，`r` 匹配第二个。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4. 函数内与函数外：变量的作用域"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "下面的代码经常会把人搞晕："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2\n",
+      "1\n"
+     ]
+    }
+   ],
+   "source": [
+    "def increase_one(n):\n",
+    "    n += 1\n",
+    "    return n\n",
+    "\n",
+    "n = 1\n",
+    "print(increase_one(n))\n",
+    "print(n)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "请你思考一下，为什么这段代码里的两个 `print` 函数输出分别是 2 和 1。\n",
+    "\n",
+    "这个问题就涉及到变量的**作用域**（*scope*）问题，也就是说在不同地方出现的同名变量和函数，可能是完全不同的两个东西：\n",
+    "* 函数定义体中的变量的作用域是该函数内，程序的其他部分不知道其存在，这种变量叫**局部变量**（*local variable*）；函数的输入参数也是局部变量，也只在函数定义体中有效；\n",
+    "* 不在任何函数、类定义体中的变量的作用域是全局的，在任何地方都可以访问，这种变量称为**全局变量**（*global variable*）；\n",
+    "* 如果局部变量和全局变量同名，函数定义体内会优先局部变量，不会把它当做全局变量。\n",
+    "\n",
+    "这样我们就能理解上面代码输出的 2 和 1 了：\n",
+    "* 第一个 `print()` 打印的是函数调用 `increase_one(n)` 的返回值，这个语句不在任何函数定义体中，所以它里面用到的变量都是全局变量：\n",
+    "    * 在调用 `increase_one()` 时参数 `n`，按照作用域原理，是全局变量 `n` 当时的值，也就是 1；\n",
+    "    * 在 `increase_one()` 函数定义内，参数 `n` 是输入参数即局部变量，带着传进来的值 1，经过加一之后返回，返回值是 2；\n",
+    "    * `print` 打印这个返回值，输出 2；\n",
+    "    * 这个过程中处理的都是局部变量，完全不影响全局变量 `n` 的值；\n",
+    "* 第二个 `print()` 打印的是全局变量 `n` 的值，输出出 1。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "以上的文字，可能需要反复阅读若干遍；几遍下来，消除了疑惑，以后就彻底没问题了；若是这个疑惑并未消除，或者关键点并未消化，以后则会反复被这个疑惑所坑害，浪费无数时间。\n",
+    "\n",
+    "顺便说一句，上面这个例子用来说明作用域的概念很有用，但是平时写程序最好别这么写，减少重名的变量可以提升代码的清晰度和可读性。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "与此相关的，我们在介绍列表等数据容器时，会为上面的规则作出重要的补充，这里先留一个伏笔。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 5. 带缺省值的参数"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "我们其实已经见过带缺省值的参数（*argument with default value*），这里我们更细致的看看这个特性。\n",
+    "\n",
+    "在函数定义中可以在某个参数后面用等号 `=` 给它一个缺省值，调用时可以省略传入这个参数的值，直接采用缺省值；当然也可以在调用时传入这个参数的值来覆盖掉缺省值。这种特性相当于给了这个函数两个版本，一个带某个参数，一个不带，不带的版本就当该参数是某个缺省值。看看下面的例子："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def greeting(name, msg='Hi'):\n",
+    "    print(f'{msg}, {name}!')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hi, Neo!\n"
+     ]
+    }
+   ],
+   "source": [
+    "greeting('Neo')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Good morning, Neo!\n"
+     ]
+    }
+   ],
+   "source": [
+    "greeting('Neo', 'Good morning')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "一个函数可以有多个带缺省值的参数，但有一个限制：所有这些带缺省值的参数只能堆在参数表的最后，也就是说你定义的参数表里，出现一个带缺省值的参数，则它后面的都必须带缺省值。如果把上面的 `greeting()` 函数的两个参数调换一下，会扔出一个 `SyntaxError: non-default argument follows default argument` 的异常。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 6. 指定参数名来调用函数"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "我们前面说过，调用函数时传入的参数值会严格按照顺序去匹配参数变量，第一个输入值赋给第一个参数变量，第二个值赋给第二个参数变量，依此类推。因为有了上面说的带缺省值参数，这个规则出现了变通的可能。\n",
+    "\n",
+    "如果一个函数有多个带缺省值的参数，我们想忽略掉某几个参数（就用其缺省值），但指定后面某一个参数的值（覆盖缺省值），例如下面这个函数："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def greeting(name, msg='Hi', punc='!'):\n",
+    "    print(f'{msg}, {name}{punc}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "在这个版本的 `greeting()` 函数中，包含一个普通参数 `name` 和两个带缺省值的参数 `msg` `punc`，如果我们想跳过 `msg` 只传入 `name`（这个是必须的，因为没有缺省值）和 `punc` 的值，那么就可用下面的语法："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hi, Neo.\n"
+     ]
+    }
+   ],
+   "source": [
+    "greeting('Neo', punc='.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "这里第一个值按照顺序位置匹配到参数变量 `name`，这叫 *positional argument*（即“按照位置顺序匹配的参数”），而按照位置下一个是 `msg`，是我们想跳过的，所以要注明参数变量名，说明下一个传入的值 `'.'` 是给 `punc` 参数变量的，这叫 *keyword argument*（即“按照参数名匹配的参数”）。\n",
+    "\n",
+    "由于所有带缺省值的参数都在普通参数的后面，所以我们只要记住：\n",
+    "* 调用函数时先传入所有不带缺省值的参数的值，严格按照函数定义的位置顺序（*positional*）；\n",
+    "* 然后想指定哪些带缺省值参数的值，就用 `变量名=值` 这样的格式在后面列出（*keyword*），未列出的就还用缺省值了。\n",
+    "\n",
+    "在后半部分，顺序就无所谓了，可以和定义时不一样，反正是用名字指定的（*keyword*），比如我们完全可以这么干："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Good nite, Neo.\n"
+     ]
+    }
+   ],
+   "source": [
+    "greeting('Neo', punc='.', msg='Good nite')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 7.  变长参数"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "到目前为止，Python 的函数定义还是很简单清晰的，无论参数还是返回值，都没什么难懂的。下面开始就要进入比较混沌的领域了。\n",
+    "\n",
+    "所谓变长参数就是函数定义时名字前面带个星号 `*` 的参数变量，这表示这个变量其实是一组值，多少个都可以。我们先来看个简单的例子："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def say_hi(*names):\n",
+    "    for name in names:\n",
+    "        print('Hi,', name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hi, Neo\n"
+     ]
+    }
+   ],
+   "source": [
+    "say_hi('Neo')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hi, Neo\n",
+      "Hi, Trinity\n"
+     ]
+    }
+   ],
+   "source": [
+    "say_hi('Neo', 'Trinity')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hi, Neo\n",
+      "Hi, Trinity\n",
+      "Hi, Morpheus\n"
+     ]
+    }
+   ],
+   "source": [
+    "say_hi('Neo', 'Trinity', 'Morpheus')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "在这个例子里，`*names` 是一个变长参数（*arbitrary argument*），调用时可以传入一个或者多个值，函数会把这些值看做一个列表，赋给局部变量 `names`——后面我们会知道，其实不是**列表**（*list*），而是一个**元组**（*tuple*）——然后我们在函数体中可以用 `for...in` 来对这个 `names` 做循环。\n",
+    "\n",
+    "> 有些中文书籍把 *arbitrary arguments* 翻译成“可变参数”或者“任意参数”。事实上，在这样的地方，无论怎样的中文翻译都是很难准确表达原意的。这还算好的，甚至还见过翻译成“武断的参数”的——这样的翻译肯定会使读者产生说不明道不白的疑惑。\n",
+    ">\n",
+    "> 所以，**入门之后就尽量只用英文**是个好策略。虽然刚开始有点吃力，但后面会很省心，很长寿——是呀，少浪费时间、少浪费生命，其实就相当于更长寿了呀！"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "在使用 *arbitrary argument* 的场合，有几点需要注意：\n",
+    "* 参数变量名最好用复数单词，一看就知道是一组数据；这个变量在函数里通常都会被 `for...in` 循环处理，用复数名词在写类似 `for name in names` 的循环语句时会很舒服、很地道（*idiomatic*），是的，写程序和学外语一样，不写则已，写就要尽量写得“地道”；\n",
+    "* 这种参数变量只能有一个，因为从它开始后面的输入值都会被当做它的一部分，多了就不知道怎么分了，显然，如果有这种参数，必须放在参数表的最后。\n",
+    "\n",
+    "上面的第二点，有一个不太常见的例外，那就是一个函数既有 *arbitrary arguments* 又有 *arguments with default values* 的情况，那么可以有两个 *arbitrary arguments*，其中第二个必须带缺省值，然后参数表排列成这样：\n",
+    "\n",
+    "`def monstrosity(*normal arguments*, *normal arbitrary argument*, *arguments with defaults*, *arbitrary argument with default*)`\n",
+    "\n",
+    "这样是完全符合语法要求的，调用时传入参数值还是按照前面讲的规则，先按照位置顺序匹配前两部分，多出来的都归 *normal arbitrary argument*；然后按照参数变量名指定对应值，没指定的都用缺省值。不过这实在是太麻烦了，不知道什么情况下才必须用这么可怕的函数，还是祈祷我们不会碰到这样的场景吧！\n",
+    "\n",
+    "当然，只有上面列出的前三个部分的情况还是有的，比如下面的例子："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def say_hi(*names, msg='Hi', punc='!'):\n",
+    "    for name in names:\n",
+    "        print(f'{msg}, {name}{punc}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hi, Neo.\n",
+      "Hi, Trinity.\n"
+     ]
+    }
+   ],
+   "source": [
+    "say_hi('Neo', 'Trinity', punc='.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 小试身手(1)\n",
+    "阅读可变参数的vfunc函数，仿写milti函数实现返回所有参数的乘积。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def vfunc(*b):\n",
+    "    a=0\n",
+    "    for n in b:\n",
+    "        a+=n\n",
+    "    return a\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "15"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "vfunc(1,2,3,4,5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 函数别名"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "在 Python 中，所有函数也是对象，证据就是它们都有对象 id。Python 会为创建的每一个对象（不管基本数据类型，还是某个 *class* 的实例）指定一个唯一的 id，可以用内置函数 `id()` 来查看，比如："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n = 42\n",
+    "id(n)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "函数也有这个 id，比如："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def _is_leap(year):\n",
+    "    return (year % 4 == 0 and year % 100 != 0) or year % 400 == 0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2989669354808"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "id(_is_leap)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "既然函数有 id，是个对象，那是什么类型的对象呢？可以用内置函数 `type` 来看："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "type(_is_leap)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "所以函数是个 `function` 类型的对象。\n",
+    "\n",
+    "既然是个对象，我们就可以用赋值语句来创建函数的**别名**（*alias*）："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "is_leap = _is_leap"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "id(is_leap)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "可以看到，这两个函数的 id 完全一样，是同一个对象的两个名字而已。我们可以用这两个名字来调用这个函数，完全没区别："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "_is_leap(2018)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "is_leap(2018)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "那么，我们为什么需要给函数取别名呢？\n",
+    "\n",
+    "很多时候是为了提供更好的代码可读性，比如在特定上下文让某个函数的作用更显而易见，比如以前的例子里，我们曾经在 `Cat` 类里给父类 `Animal` 的 `voice()` 方法定义别名叫 `meow()`。\n",
+    "\n",
+    "还有一种情况是一个函数需要在运行时动态指向不同的实现版本。这里只简单描述一个典型场景：假定我们要渲染一段视频，如果系统里有兼容的显卡（GPU），就调用显卡来渲染，会更快更省电，如果没有则用 CPU 来渲染，会慢一点和更耗电一点，于是我们把用 GPU 渲染的算法写成函数 `_render_by_gpu()`，用 CPU 渲染的算法写成函数 `_render_by_cpu()`，而检测是否存在可用 GPU 的算法写成函数 `is_gpu_available()`，然后可以用下面的方法来定义一个函数 `render`：\n",
+    "\n",
+    "```python\n",
+    "if is_gpu_available():\n",
+    "    render = _render_by_gpu\n",
+    "else:\n",
+    "    render = _render_by_cpu\n",
+    "```\n",
+    "\n",
+    "这样 `render()` 就成为一个当前系统中最优化的渲染函数，在程序的其他地方就不用管细节，直接用这个函数就好。这就是动态函数别名的价值。\n",
+    "\n",
+    "顺便说一句，在任何一个工程里，为函数或者变量取名都是**很简单却不容易**的事情——因为可能会重名（虽然已经尽量用变量的作用域隔离了），可能会因取名含混而令后来者费解，所以，仅仅为了少敲几下键盘而给一个函数取个更短的别名，实际上并不是好主意，更不是好习惯。尤其现在的编辑器都支持自动补全和多光标编辑的功能，变量名长点不是什么大问题。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 匿名函数"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "有的函数需要两个甚至更多名字，有的函数却一个也不要，人生就是这么丰富多彩啊！\n",
+    "\n",
+    "所谓匿名函数，就是有时候我们需要一个函数，但就在一个地方，用完就扔，再也不会用了，Python 对这种情况提供了一个方便的语法，不需要 `def` 那套严肃完整的语法，一行就可以写完一个函数，这个语法使用关键字 `lambda`。`lambda` 是希腊字母 `λ` 的英语音译，在计算机领域是个来头不小的词儿，代表了一系列高深的理论，[和阿伦佐·丘奇（Alonzo Church）的理论有关](https://en.wikipedia.org/wiki/Lambda_calculus)，有兴趣的话可以自行研究。\n",
+    "\n",
+    "不过目前我们不需要管那么多，只要了解怎么快速创建“用过即扔”的小函数就好了。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def add(x, y):\n",
+    "    return x + y\n",
+    "add(3, 5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "我们可以用 lambda 来改写："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "add = lambda x, y: x + y\n",
+    "add(3, 5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "甚至更简单一点，名字也不要了："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "(lambda x, y: x + y)(3, 5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "最后这种形式，就是典型的匿名函数了。简单地说，`lambda` 可以生成一个函数对象，出现在所有需要一个函数的地方，可以将其赋给一个变量（如上面的 `add`），这个变量就称为函数变量（别名），可以当函数用；也可以直接把 `lambda` 语句用括号括起来当一个函数用（上面后一种形式）。\n",
+    "\n",
+    "在 Python 官方文档中，`lambda` 语句的语法定义是这样的：\n",
+    "\n",
+    "`lambda_expr ::= \"lambda\" [parameter_list] \":\" expression`\n",
+    "\n",
+    "这个语法定义采用的是 [巴克斯范式（BNF）](https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form)标注，现在不明白没关系（虽然对照上面的例子也能猜出个大概吧），以后我们会专门介绍。\n",
+    "\n",
+    "其实也很简单，就是这个样子：\n",
+    "\n",
+    "```python\n",
+    "lambda x, y: x + y\n",
+    "```\n",
+    "\n",
+    "先写上 `lambda` 关键字，其后分为两个部分，`:` 之前是参数表，之后是表达式，这个表达式的值，就是这个函数的返回值。**注意**：`lambda` 语句中，`:` 之后有且只能有一个表达式，所以它搞不出很复杂的函数，比较适合一句话的函数。\n",
+    "\n",
+    "而这个函数呢，没有名字，所以被称为 “匿名函数”。\n",
+    "\n",
+    "`add = lambda x, y: x + y`\n",
+    "\n",
+    "就相当于是给一个没有名字的函数取了个名字。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 小试身手（2）"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "1.判断奇数  \n",
+    "判断奇数的函数lambda函数的定义和使用  \n",
+    "（1）使用匿名函数编写一个函数isOdd，能够判断一个整数是否是奇数，返回True或False。\n",
+    "isodd = lambda x: x%2 == 1\n",
+    "（2）请写出输入一个数x，调用isOdd函数判断x是否是奇数的程序段。  \n",
+    "（3）请写出求50-100之间所有奇数的和的程序段，（使用isOdd实现奇数判断）。    \n",
+    "（4）请写出求50-100之间所有偶数的和的程序段（使用isOdd实现偶数判断）。\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "isodd = lambda x: x%2 == 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "2.构造整数\n",
+    "问题描述\n",
+    "求由任意个整数上的个位数构造的新整数并输出。\n",
+    "具体要求\n",
+    "（1）编写lambda函数getLastBit，该函数返回正整数number的个位数，例如正整数1234，则返回4。\n",
+    "（2）编写可变参数的函数makeNumber，求任意个整数的个位数构成的一个新整数。\n",
+    "（3）输出（45、81、673、938）4个数的个位数构成的新整数，得到的新的整数为：5138。请填空完整程序。\n",
+    "\n",
+    "新整数是5138"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#定义lambda函数getLastBit返回一个数的个位数\n",
+    "getLastBit=                                \n",
+    "\n",
+    "#定义一个可变参数的函数makeNumber，求任意个整数的个位数构成的一个新整数\n",
+    "def makeNumber(a,*b):\n",
+    "        s=getLastBit(a)\n",
+    "         \n",
+    "\n",
+    "\n",
+    "        return s\n",
+    "\n",
+    "#输出（45、81、673、938）4个数的个位数构成的新整数。\n",
+    "print(f\"新整数是{makeNumber(45,81,673,938)}\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.7.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Lab13.ipynb b/Lab13.ipynb
new file mode 100644
index 0000000..26a33f6
--- /dev/null
+++ b/Lab13.ipynb
@@ -0,0 +1,413 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 实践13  递归函数\n",
+    "1.理解递归  \n",
+    "2.掌握递归函数的定义和调用\n",
+    "3.理解递归函数的调用过程"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1.递归"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "递归是个很有趣也很有用的概念。所谓“**递归**（*recursion*，*recursive*）”，就是“用自己定义自己”，或者“自己包含自己”。举个例子，大家都听过的这个故事就是递归的经典例子：\n",
+    "\n",
+    "```\n",
+    "从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是这样的：从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是这样的：从前有座山，……\n",
+    "```\n",
+    "\n",
+    "如果我们把这个故事叫做 A，那么 A 的定义可以写作这样：\n",
+    "\n",
+    "```\n",
+    "A ::= 从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是这样的：A\n",
+    "```\n",
+    "\n",
+    "上面这个定义里的 `::=` 的意思是“定义为”，这种语法叫 [巴科斯范式（BNF）](https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form)。这个定义里最有意思的地方是，在 A 的定义中用到了 A 本身，如果我们把 A 的定义代入 `::=` 右边出现的 A，就会出现无限循环下去的情况，这恰恰是原来那个故事的 point 所在。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "如果把这个故事写成 Python 代码，大致是这样子的\n",
+    "\n",
+    "```python\n",
+    "def a_monk_telling_story():\n",
+    "    print('从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是这样的：')\n",
+    "    return a_monk_telling_story()\n",
+    "```\n",
+    "\n",
+    "这个简短的程序体现了递归的本质：一个函数的定义中调用了自己。不过我们可不能真写这样的程序，因为它会无限的自我调用下去，形成“无限循环”，或者更难听的词儿“死循环”——循环到死。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. 递归的基本概念"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "递归在编程中很有用，要了解这一点，我们可以来了解递归的来源：又是数学。人们很早就意识到，数学上有一类东西，很不好写出一个公式来计算，但用自己来定义自己反而会很清晰和严谨，比如大名鼎鼎的斐波那契（*Fibonacci*）数列，这个数列不仅有很高的理论价值，而且有很多数学和其他学科里的直接应用，它的定义是："
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\\begin{equation*}\n",
+    "    f(n) = \\begin{cases}\n",
+    "               0               & n = 0\\\\\n",
+    "               1               & n = 1\\\\\n",
+    "               f(n-1) + f(n-2) & \\text{otherwise}\n",
+    "           \\end{cases}\n",
+    "\\end{equation*}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "也就是说，开头两项是 0 和 1，之后每一项都是前两项之和，这个定义来自数学家 Leonardo Fibonacci 对兔子生长问题的研究：\n",
+    "* 第一个月初有一对刚诞生的兔子；\n",
+    "* 第二个月之后（第三个月初）它们可以生育；\n",
+    "* 每月每对可生育的兔子会诞生下一对新兔子；\n",
+    "* 兔子永不死去。\n",
+    "\n",
+    "在这一模型下，每个月兔子的数量就可以简单直观地用上面的递归表达式来表示。而要写出斐波那契（Fibonacci）数列的通项公式（即通过 n 的有限次运算求出第 n 项的值）就没那么容易了，当然这个公式目前不算什么了，长这样："
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\\begin{equation*}\n",
+    "    f(n) = \\frac{1}{\\sqrt{5}}((\\frac{1+\\sqrt{5}}{2})^{n} - (\\frac{1-\\sqrt{5}}{2})^{n})\n",
+    "\\end{equation*}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "所以可以看出，递归表达式和通项表达式很不一样，有时候递归表达式代表了问题的本质，从递归表达式出发就可以一个一个计算出值来，而通项表达式更方便快速计算出特定某一项来，却完全看不出和最初的问题有什么关联。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "另一个经典的递归例子是阶乘的定义，n 的阶乘 $n!$ 就是从 1 开始一直乘到 n，递归定义很简单："
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\\begin{equation*}\n",
+    "n! = (n-1)! \\times n\n",
+    "\\end{equation*}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "可要写出它的通项，怎么写呢？当然我们可以写 `n! = 1x2x3x...xn`，但是 `...` 并不是在数学上严谨的一个东西啊。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "为了用 Python 计算阶乘的值，可以有两种方法，循环，和递归。先来看循环的方法："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result = 1\n",
+    "for i in range(5):\n",
+    "    result = result * (i+1)\n",
+    "print(result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "就是把 1~n 的整数都乘起来，下面看看递归的方法："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def f(n):\n",
+    "    if n == 1:\n",
+    "        return 1\n",
+    "    else:\n",
+    "        return n * f(n-1)\n",
+    "    \n",
+    "f(5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "和前面的版本结果一样。这个实现基本就是阶乘数学定义的翻译，很容易明白，但我们需要格外关注的是在函数里调用自己这件事。我们可以一层一层的分析一下在函数调用 `f(5)` 之后到底发生了什么。"
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![image.png](attachment:image.png)<img src=\"assets/recursion-factorial.png\" width=\"800\">"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "如上图所示，当 f(5) 被调用之后，函数开始运行……\n",
+    "* 因为 `5 > 1`，所以，在计算 `n * f(n-1)` 的时候要再次调用自己 `f(4)`；所以必须等待 `f(4)` 的值返回；\n",
+    "* 因为 `4 > 1`，所以，在计算 `n * f(n-1)` 的时候要再次调用自己 `f(3)`；所以必须等待 `f(3)` 的值返回；\n",
+    "* 因为 `3 > 1`，所以，在计算 `n * f(n-1)` 的时候要再次调用自己 `f(2)`；所以必须等待 `f(2)` 的值返回；\n",
+    "* 因为 `2 > 1`，所以，在计算 `n * f(n-1)` 的时候要再次调用自己 `f(1)`；所以必须等待 `f(1)` 的值返回；\n",
+    "* 因为 `1 == 1`，所以，这时候不会再次调用 `f()` 了，`f(1)` 返回值是 `1`；\n",
+    "* 下一步，`f(2)` 返回值是 `2 * 1 = 2`；\n",
+    "* 下一步，`f(3)` 返回值是`3 * 2 = 6`；\n",
+    "* 下一步，`f(4)` 返回值是`4 * 6 = 24`；\n",
+    "* 下一步，`f(5)` 返回值是`5 * 24 = 120`。\n",
+    "\n",
+    "至此，函数调用 `f(5)` 才执行完，最终返回值是 `120`。这个调用中“**递归**（*recursively*）”调用了四次 `f()` 自己。\n",
+    "\n",
+    "> *Recursive* 本来就是“反复、重复”的意思。\n",
+    "\n",
+    "试着在自己脑子里把这个过程走通，有点烧脑，不过搞清楚了也很有意思。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 递归的终止"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "从上面的例子，我们可以发现，最终 f(1) 不再需要递归，可以直接返回一个确定的值，这一步是递归的转折点，特别重要，如果没有这个，递归就会无穷无尽的重复下去，永远得不到结果，就像最开始我们写的那个老和尚讲故事的例子一样。\n",
+    "\n",
+    "把我们计算阶乘的例子中的 `if n == 1:` 条件去掉，直接写成这样：\n",
+    "\n",
+    "```python\n",
+    "def f(n):\n",
+    "    return n * f(n-1)\n",
+    "```\n",
+    "\n",
+    "如果运行这个版本的 `f(5)`，会得到一个运行时异常 `RecursionError: maximum recursion depth exceeded`，因为 Python 对递归次数是有限制的，达到一定次数还没返回的递归会抛出这个异常。\n",
+    "\n",
+    "我们写递归函数的时候，要特别小心的确认递归的终止条件，就和循环中的退出条件一样，一定不能出现无限递归或者死循环的情况。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 递归的好处与代价"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "从理论上可以证明，所有递归（*recursion*）都可以改写为循环（*iteration*），反之所有循环也都可以用递归改写。那么我们写递归这样的算法好处是什么呢？\n",
+    "\n",
+    "> Alonzo Church 和 Alan Turing 两位现代计算机科学的奠基者的[经典论文](https://en.wikipedia.org/wiki/Church%E2%80%93Turing_thesis)提供了证明，前提是内存管够。\n",
+    "\n",
+    "最大的好处是清晰易懂。递归通常用于本质上就带有递归特性的问题（如前面所见的例子），递归算法几乎原样展现了问题的本质，容易理解也容易编写。\n",
+    "\n",
+    "另外的好处是，对某些问题的算法，递归是最优化的，比如树型结构的遍历。\n",
+    "\n",
+    "凡事有得必有失。递归的代价是什么呢？\n",
+    "\n",
+    "主要代价有二：递归一般会使用更多的内存，因为每次调用自身都需要建立新函数调用所需要的环境，占用相应的资源，一直迭代到最深层开始返回才会释放这些资源，对此有些编程语言会在编译器和运行时进行优化，比如“**尾递归优化**（*tail-recursion optimization, TRO*）”，能够将这种消耗免除，但 Python 并不支持（以后也不会支持），所以 Python 会限制递归的层次，超过就扔出 `RecursiveError`。\n",
+    "\n",
+    "另一个代价是，有的时候递归算法不是最高效的，这涉及到算法分析，我们目前还不用深入，知道有这些代价就好。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "对于我们来说，了解这种思考问题的方法，在碰到适合的问题时能多一个思路，就是相当不错的收获了。"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 小试身手"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "1. 使用递归求最大公约数  \n",
+    "（1）编写函数gcd(m,n)，可以如下递归定义:  \n",
+    "* 如果m%n为0，那么gcd(m,n)的值为n。\n",
+    "* 否则，gcd(m,n)的值是gcd(n,m%n)\n",
+    "（2）调用gcd函数，测试gcd的正确性\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "5\n"
+     ]
+    }
+   ],
+   "source": [
+    "def gcd(m,n):\n",
+    "    if m%n == 0:\n",
+    "        return n\n",
+    "    else:\n",
+    "        return gcd(n,m%n)\n",
+    "print(gcd(15,25))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "2.使用递归方法逆序输出一个整数中的数字  \n",
+    "（1）编写函数reverseDisplay(value)，可以如下递归定义：  \n",
+    "* 如果value大于0，那么输出个位数，并继续递归调用reverseDisplay(value//10)\n",
+    "* 否则 函数结束  \n",
+    "\n",
+    "（2）调用reverseDisplay函数，测试reverseDisplay的正确性。  \n",
+    "\n",
+    "reverseDisplay(12345)  \n",
+    "54321  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "54321"
+     ]
+    }
+   ],
+   "source": [
+    "def reverseDisplay(value):\n",
+    "    pass\n",
+    "reverseDisplay(12345)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "3.使用递归方法逆序输出一个字符串中的字母  \n",
+    "（1）编写函数reverseDisplay(s)，可以如下递归定义：  \n",
+    "\n",
+    "* 如果s的长度不等于1，那么s串去首字符，继续递归调用。  \n",
+    "* 输出字符串的首字符。\n",
+    "\n",
+    "（2）调用reverseDisplay函数，测试reverseDisplay的正确性。  \n",
+    "\n",
+    "reverseDisplay(\"abcde\")  \n",
+    "edcba  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "edcba"
+     ]
+    }
+   ],
+   "source": [
+    "def reverseDisplay(s):\n",
+    "    if len(s)!=1:\n",
+    "        reverseDisplay(s[1:])\n",
+    "    print(s[0],end=\"\")\n",
+    "reverseDisplay(\"abcde\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.7.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}