51194507011_stu_ecnu_edu_cn
/
CRE2
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

Add Lab01-06

master
SU Bin 4 years ago
parent
01af1dc7e9
commit
277215cfee
6 changed files with 3671 additions and 0 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +410
    -0
      实践1 - Python初印象.ipynb
  2. +1261
    -0
      实践2 - Python基本语法.ipynb
  3. +601
    -0
      实践3 - 模块和函数.ipynb
  4. +629
    -0
      实践4 - 逻辑判断和选择结构.ipynb
  5. +418
    -0
      实践5 - 循环结构.ipynb
  6. +352
    -0
      实践6 - 异常.ipynb

+ 410
- 0
实践1 - Python初印象.ipynb View File

@ -0,0 +1,410 @@
{
"cells": [
{
"cell_type": "raw",
"metadata": {},
"source": [
"实践1 python初印象\n",
"学习目标\n",
"1.熟悉Jupyter lab交互开发环境\n",
"2.掌握Python 语句的编写，运行和修改\n",
"3.阅读Python微程序，尝试模仿改写程序"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 实践1 初识python程序"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1. 安装Jupyter lab \n",
" 如要在自己电脑本地使用 Jupyter Lab 需要在命令提示符窗口（CMD）先用 Python 的包管理工具 pip 来安装： \n",
" pip install jupyterlab \n",
" 然后就可以用 \n",
" jupyter lab \n",
" 来运行 Jupyter Lab，打开 notebook 进行交互式编程的尝试"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2.创建使用Notbook文件 \n",
" （1）Notbook文件 \n",
" 菜单命令 New Notebook 创建一个新的Notbook文件 \n",
" （2）单元格 \n",
" Notbook文件是有若干单元格构成，单元格的类型可区分为：code、Markdown、RAW。 \n",
" code类型的单元格中可以编写一条或多条python语句。按上方三角形Run按钮执行，或快捷键ctrl+enter。\n",
" RAW类型的单元格是纯文本 \n",
" Markdown类型的单元格支持Markdown格式，请自行查阅。 \n",
" （3）使用工具栏命令可以增加，复制，删除，移动单元格。 "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#示例1 一条语句\n",
"print(\"Hello Python World!\")"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"说明： \n",
"（1）print是一个Python标准输出函数，函数的功能是执行“打印”的功能。 \n",
"（2）\"Hello, Python World!\"是字符串，在一对双引号中你可以输入任意文字，包括中文和标点符号，但使用引号要慎重。 \n",
"（3）一对圆括号是函数的标志，和print函数名配合使用，不可缺少。 \n",
"（4）圆括号里的是函数的参数。此处参数是一个字符串，也就是print函数输出的内容。 \n"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"请在此下方增加一个code单元格，输入一个print命令并执行"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"重要的事情说三遍\n",
"Hello Python World!\n",
"Hello Python World!\n",
"Hello Python World!\n"
]
}
],
"source": [
"# 示例2 多条语句\n",
"#Fl1-1 重要的事情说三遍\n",
"print(\"重要的事情说三遍\")\n",
"print(\"Hello Python World!\")\n",
"print(\"Hello Python World!\")\n",
"print(\"Hello Python World!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3.认识程序的语法错误\n",
"当编写的python程序代码没有遵循Python的语法规定时，会报错显示错误信息。学习阅读错误信息，快速定位错误位置，编写程序的基本功。 \n",
" File \"C:\\Users\\qtzhu\\AppData\\Local\\Temp/ipykernel_5712/281370357.py\", line 1 \n",
" print(\"重要的事情说三遍) <-- 出错的语句 \n",
" ^\n",
"SyntaxError: EOL while scanning string literal \n",
"出错的类型:语法错误 文本串没有结束 \n",
" \n",
"下面程序有三处语法错误，你能找出来吗？(每找到一个错误，修改后重新执行，阅读错误信息提示)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"重要的事情说三遍)\n",
"print(\"Hello Python World!\")\n",
"print(\"Hello Python World!\"\n",
"prin(\"Hello Python World!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 4.阅读Python微程序"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Fl1-2\n",
"s = 99999 * 99999\n",
"print(s)"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"##### 对此程序简单解读如下：\n",
"（1）s是一个变量，它引用不同数据的值。 \n",
"（2）\tPython语言允许采用大写字母、小写字母、数字、下划线_和汉字等字符及其组合给变量命名，但名字的首字母不能是数字，中间不能出现空格。 \n",
"（3）\tPython语言中，“=”表示赋值运算，左侧变量s引用等号右侧的计算结果，包含赋值运算符（=）的语句称为赋值语句。 \n",
"（4）\tprint函数可以输出字符串，例如\"Hello Python World\"，也可以直接输出变量（如s作为变量名）的值。 \n",
"（5）\tPython中不需要加符号表示语句结束，换行表示一条语句的结束。 \n",
"（6）\tFL1-2的程序功能是计算99999*99999并输出结果。 \n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Apr\n"
]
}
],
"source": [
"# Fl1-3\n",
"months=\"MonFebMarAprMayJunJulAugSepOctNovDec\" \n",
"monthAbbrev = months[(4-1)*3:(4-1)*3+3]\n",
"print(monthAbbrev)"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"##### 对此程序简单解读如下： \n",
"（1）\"JanFebMarAprMayJunJulAugSepOctNovDec\" 是一个字符串常量，一对西文双引号是字符串常量的界定符，一对西文单引号也是字符串常量的界定符。 \n",
"（2）months是字符串变量。可以通过[ ]和下标来访问字符串中的一个或连续多个字符。 \n",
" 一个字符：month[i] ，i表示下标，下标从0开始，month[0]表示第一个字符。 \n",
" 多个字符：month[a:b]表示下标从a到b-1的子串。当n=1时，month[0:3]表示’Jan’ \n",
"（3）FL1-3的程序功能是通过计算从字符串months中读出第4月的月份缩写。\n",
"（4）试将第2句中的4改为1到12的任意整数，观察运行结果。\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Fl1-4\n",
"name=input(\"姓名：\")\n",
"gender=input(\"性别:\")\n",
"if gender==\"男\":\n",
" print(\"{}先生,您好!\".format(name))\n",
"else:\n",
" print(\"{}女士,您好!\".format(name))"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"对此程序简单解读如下：\n",
"（1）input函数是一个标准输入函数，接受从键盘输入的字符串数据。函数的参数是一个字符串。执行input函数，首先会输出字符串，提示用户要输入的数据是什么，然后等待用户键盘输入数据，按回车键结束。程序开始的两条输入语句分别接受姓名和性别，数据类型为字符串。\n",
"（2）if语句是一条选择语句，根据条件gender==\"男\"为真还是为假，进行不同的处理。\n",
"（3）“==”是关系运算符”等于” ，判断左右两边是否相等，相等为True，不相等为False。注意和赋值运算符“=” 区分。\n",
"（4）Python采用严格的“缩进”（指每一行代码开始前的空白区域）来表明程序的格式框架，即表示代码之间的包含和层次关系。两句print语句缩进表示了所属关系。\n",
"（5）\"{}先生,您好!\".format(name)是格式化的字符串，name变量的值在输出时出现在{}位置。\n",
"（5）FL1-4的功能是输入姓名和性别，根据性别的不同，选择不同的称呼输出问候语。\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Fl1-5\n",
"n=int(input(\"n=\"))\n",
"s=0\n",
"for i in range(n+1):\n",
" s=s+i\n",
"print(\"s=1+2+...{}={}\".format(n,s))"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"对此程序简单解读如下：\n",
"（1）input函数能够接受一个键盘输入的字符串。int函数将输入的字符串转化整数，例如输入100，第一条语句的功能为从键盘接受一个整数100，赋值给变量n。\n",
"（2）Python通过保留字for实现迭代循环，基本使用方法如下：\n",
" for <循环变量> in <可迭代对象> :\n",
" <语句块>\n",
"（3）range(n+1)函数生成一个0~n的整数序列，变量i遍历取值整数序列0~n中的每一个整数，执行s=s+i，实现将序列中每一个整数累加到s。\n",
"（4）print函数中使用字符串的format方法构造了一个格式输出串，每一个占位槽{}对应一个format函数的一个参数。此处第一个{}对应n的值，第二个{}对应s的值。\n",
"（5）FL1-5的程序功能是输入一个n，累计1到n的所有整数的和并输出。\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Fl1-6\n",
"nums = [12,50,21,56,8,19]\n",
"n=len(nums)\n",
"s=sum(nums)\n",
"average=s/n\n",
"print(\"average=\",average)"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"对此程序简单解读如下：\n",
"（1）nums是一个列表变量，其中存储了一组整数。\n",
"（2）len和sum是内置函数，len函数求一个序列的长度，可以计算列表、字符串等对象的长度。sum函数是累加和函数，返回列表nums中所有整数的和。\n",
"（3“/”是除法运算符,执行除法运算。\n",
"（4）FL1-6的程序功能是求得一组整数的平均值并输出。\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Fl1-6-1\n",
"def mean(numbers):\n",
" s = 0.0\n",
" for num in numbers:\n",
" s = s + num\n",
" return s / len(numbers)\n",
"\n",
"nums = [0,1,2,3,4,5,6,7,8,9]\n",
"print(mean(nums))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"对此程序简单解读如下：\n",
"（1）nums是一个列表变量，其中存储了一组整数。\n",
"（2）def定义个一个函数mean，函数有一个列表参数numbers，函数实现的功能是求列表numbers的平均值，return语句返回平均值\n",
"（3）mean(nums)是调用函数mean的语句，讲列表nums传递（赋值）给列表参数numbers，函数返回nums的平均值。\n",
"（4）FL1-6的程序功能是求得一组整数的平均值并输出。\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 小试身手 "
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"（1）使用for语句改写下面程序，实现一下输出。\n",
"重要的事情说三遍\n",
"Hello Python World!\n",
"Hello Python World!\n",
"Hello Python World!"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"重要的事情说三遍\")\n",
"print(\"Hello Python World!\")\n"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"（2）改写程序Fl1-2，实现求任意两个整数的乘积并输出。\n",
" 要求：增加变量a和b，表示乘法运算的2个操作数，改写乘法的表达式。\n",
" a变量和b变量的值由用户输入，输入两个整数。\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"s = 99999 * 99999\n",
"print(s)"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"（3）改写程序FL1-3.py，实现输入一个月份，输出对应的英文缩写。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"months=\"MonFebMarAprMayJunJulAugSepOctNovDec\" \n",
"n = 4\n",
"monthAbbrev = months[(n-1)*3:(n-1)*3+3]\n",
"print(monthAbbrev)"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"(4)改写程序FL1-3.py，实现顺序输出12月份对应的英文缩写。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"months=\"MonFebMarAprMayJunJulAugSepOctNovDec\" \n",
"n = 4\n",
"monthAbbrev = months[(n-1)*3:(n-1)*3+3]\n",
"print(monthAbbrev)"
]
}
],
"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
}

+ 1261
- 0
实践2 - Python基本语法.ipynb
File diff suppressed because it is too large
View File


+ 601
- 0
实践3 - 模块和函数.ipynb View File

@ -0,0 +1,601 @@
{
"cells": [
{
"cell_type": "raw",
"metadata": {},
"source": [
"函数与模块\n",
"1.理解函数的基本概念；\n",
"2.掌握Python内置函数的使用；\n",
"3.掌握Python标准模块的引入；\n",
"4.掌握math模块中常用数学函数的使用；\n",
"5.理解函数的定义和调用。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 函数与模块"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1.函数"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"程序里的函数概念完全来自数学里的函数。我们先来看看数学里的函数。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 函数的基本概念"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"在数学里，我们可以定义一个函数，函数有一些*自变量*，也就是一些**输入**，**函数定义**就是定义如何通过这些输入计算出*函数的值*，也就是**输出**。下面是个典型的函数定义的例子："
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\n",
"\\begin{align}\n",
"f(a, b) = \\sqrt{a^2 + b^2}\n",
"\\end{align}\n",
"$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"函数定义好之后，随时可以用具体的值送进去算出一个具体的函数值，比如：\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\n",
"\\begin{align}\n",
"f(1, 2) = \\sqrt{5}\n",
"\\end{align}\n",
"$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\n",
"\\begin{align}\n",
"f(3, 4) = 5\n",
"\\end{align}\n",
"$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\n",
"\\begin{align}\n",
"f(2, 6) = 2\\sqrt{10}\n",
"\\end{align}\n",
"$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"程序里的函数也是这样，我们先要定义函数，也就是定义它的名字（叫做 **函数名** *function name*）、若干输入变量（叫做 **参数** *argument*）以及如何通过输入变量算出函数的值（叫做 **返回值** *return value*）；一旦定义好，就可以在程序的其他地方随时使用这个函数，给它具体的参数值，它就给出具体的返回值。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 调用现成的函数"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"我们先看看怎么用函数，术语叫做函数**调用**（*call*），因为 Python 本身自带了很多已经定义好的函数，我们可以直接拿来用。其中有一些我们之前已经用过了：\n",
"* `print(a, b,...)`：在命令行输出界面打印输入的参数（可以是各种类型的数据）；\n",
"* `type(x)`：返回参数 x 的数据类型；\n",
"* `abs(x)`：返回参数 x（整数或者浮点数）的绝对值。\n",
"\n",
"这几个都是 Python 的内置函数，可以直接用。我们下面来看两个其他的例子。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"第一个例子是另一个 Python 内置函数，叫做 `isinstance(x, c)`，它有两个输入参数，第一个是一个数据，第二个是一个数据类型，如果第一个数据是第二个数据类型，`isinstance` 函数返回 `True`，否则就返回 `False`。所以 `isinstance` 可以用来判断某个值或者变量是不是某种类型，下面是例子："
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"isinstance(a, int)"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"isinstance(a, float)"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"isinstance(g, float)"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 40,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"isinstance(True, str)"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"isinstance(True, bool)"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 42,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"isinstance('abracadabra', str)"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"isinstance(True, bool) and not isinstance('abracadabra', float)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2.模块\n",
"\n",
"第二个例子是 Python 的平方根函数 `math.sqrt(x)`，这个函数前面有个 `math`，这表示函数 `sqrt(x)` 不在 Python 的内置环境中，而是放在一个叫 `math` 的函数包（学名叫 **模块** *module*）里，关于模块我们以后会专门介绍。要使用这种函数，第一种方法是：\n",
"* 先 **引入**（*import*）对应的函数包；\n",
"* 使用时函数名前面要带上模块的名字，中间加个 `.`。\n",
"\n",
"就像下面这样："
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"4.0"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import math\n",
"math.sqrt(16)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"另外一种方法是，从对应的模块里指明引入这一个函数，使用时就不用带上模块名了："
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"6.324555320336759"
]
},
"execution_count": 45,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from math import sqrt\n",
"sqrt(40)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"我们可以看到 `sqrt(x)` 函数可以接受整数或者浮点数输入，返回值是浮点数。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3. 定义函数"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"有了 `sqrt(x)` 这个函数，我们可以定义一个函数来实现前面举例的那个数学里的函数 `f(a, b)` 了。在 Python 里函数的定义以关键字 `def` 开始，后面依次是函数名、小括号括起来的参数列表和一个冒号，之后的代码就是函数的算法定义，直到关键字 `return` 开始的 **返回语句**，这个返回语句会终止函数的运行，并把 `return` 后面的值作为函数的返回值，回到调用函数的地方。看起来有点抽象，我们看看例子： "
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"5.0\n"
]
}
],
"source": [
"from math import sqrt\n",
"\n",
"def f(a, b):\n",
" return sqrt(a**2 + b**2)\n",
"\n",
"result = f(3, 4)\n",
"print(result)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"上面的代码很短，但是很重要，我们务必要搞懂这里的每一个细节。\n",
"\n",
"首先第一行是引入 `sqrt(x)` 函数，因为我们下面定义的函数要用到它。\n",
"\n",
"然后是函数定义 `def f(a, b):`，关键字 `def` 打头，后面是函数名 `f`、参数列表 `(a, b)` 和一个冒号，这表示函数 `f` 接受两个参数，一个叫 `a` 一个叫 `b`。下面一行就是**函数体**（*function body*），里面可以写很多东西，只要最后有一个 `return` 指明函数返回值就行，注意 Python 的函数可以没有返回值（`return` 后面什么都不写就行了），也可以返回多个值（`return` 后面写多个值，用逗号隔开）。\n",
"\n",
"我们这个例子因为很简单，就一句话就能搞定：函数返回值等于 a 平方加 b 平方再开方。注意函数体的代码缩进了一些，和其他的行都是顶着行首书写不一样，这是 Python 的缩进规则要求的，下面的插播会做出解释。\n",
"\n",
"然后是调用函数的例子，它是这么进行的：\n",
"1. 首先用 3 和 4 作为参数来调用 `f()` 函数；\n",
"2. 函数 `f()` 开始执行，把值 3 赋给参数变量 a，4 赋给 b，然后执行函数体；\n",
"3. 函数体计算出返回值 5.0 并返回；\n",
"4. 用返回值 5.0 替换掉 `f()` 的位置，相当于执行赋值 `result = 5.0`\n",
"5. 用 5.0 作为参数值调用内置的 `print()` 函数，打印出 5.0（`print()` 没有返回值）。\n",
"\n",
"顺便说一句，熟练之后我们可以把后两行简化成一句 `print(f(3, 4))`，效果是完全一样的。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 插播：代码缩进"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"所谓代码缩进就是一行代码不顶格写，而是在行首空若干格再写。缩进可以很多层，比如 Python 中第一层缩进空四格，第二层缩进空八格，第三层缩进空十二格，依此类推。程序员都喜欢用“**等宽字体**（*fix-width font*）”，就是因为等宽字体在缩进时非常整齐美观。\n",
"\n",
"缩进是为了让代码层次更加鲜明地呈现出来。比如上面函数定义的代码，函数体的部分是“隶属于”函数定义 `def` 语句的，是它的组成部分，所以缩进一层表示这个从属关系；而后面的函数调用则不是，所以最后两行不缩进，和 `def` 语句平齐，代表是同一层级的代码。\n",
"\n",
"在 Python 中缩进是强制的，如果不进行正确的缩进，比如如果函数体没有正确的缩进，解释器会因为找不到必须的部分而报错。\n",
"\n",
"目前主流的程序编辑器都提供了自动缩进、自动排版的功能，在 VSCode 和 Jupyter Notebook 中书写代码时大部分时候都会自动正确的缩进，所以很方便。\n",
"\n",
"对于初学者来说，知道有这么回事，然后多看，慢慢就会习惯成自然，和多听多看学语言是差不多的道理。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 4.函数的调用 \n",
"函数定义后，未经调用，是不会执行的。需要时使用函数调用语句。 \n",
"在函数调用的时候要求传递对应的值给形参，这个传递的值称为实际参数，简称实参。参数是可选的，也就是说函数可以不包括参数，例如：random.random() 就不包含参数。 \n",
"根据函数是否有返回值，函数的调用也是不同的。如果函数有返回值，函数调用的时候需要安排接受返回值。 \n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"6.324555320336759"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# 可以是赋值语句，将返回值赋值给一个变量\n",
"z = f(2,6)\n",
"z"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"50.0"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# 可以是表达式语句，将返回值作为表达式的一个数值，继续参加运算\n",
"z = f(3,4)*10\n",
"z\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"11.180339887498949"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# 可以作为函数调用的实参\n",
"z=f(f(3,4),10)\n",
"z\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 函数的意义"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"函数是编程中最重要的概念之一。实现它有助于我们实现程序的“**模块化**（*modulization*）”，我们可以把特定的工作用一个函数来实现，然后在需要的地方反复地调用它。这是一种代码重用的方法，一个函数就好像乐高积木里的一个组件，我们可以通过组合各种不同功能的函数来实现复杂的目标。\n",
"\n",
"函数还是协作编程的基础。如果我们实现了一个很有用的函数，我们可以写一个文档说明函数的输入参数和返回值是什么，这样的文档叫做**调用接口**（*interface*），别人都可以照此使用我们写的函数，甚至不需要了解它是怎么实现的（比如我们就直接拿了 `math.sqrt()` 来用而不需要自己写一个）。函数天生就把自己的接口和实现分离开，让协作和复用成果更容易。\n",
"\n",
"**模块化** 和 **接口独立** 是编程时最重要的两个思维模型（没有之一），我们在后面还会深入介绍。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 小试身手\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### （1）使用math模块的数学函数。 \n",
"导入数学库math。然后输入以下表达式理解math中函数的使用，注意结果值的数据类型。 \n",
"math.sqrt(2*2+3*3)、 math.log10(100)、 math.exp(2)、math.fmod(4,3)、math.sin(2*math.pi)、\n",
"math.gcd(12,9)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[数学库math](https://docs.python.org/zh-cn/3/library/math.html)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### （2）自定义求矩形面积的函数"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#定义一个函数getArea(length,width)，计算长为length,宽为width的矩形面积。 \n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#试着用不同的方式调用getArea函数，验证函数的正确性\n",
"\n"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"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
}

+ 629
- 0
实践4 - 逻辑判断和选择结构.ipynb
File diff suppressed because it is too large
View File


+ 418
- 0
实践5 - 循环结构.ipynb
File diff suppressed because it is too large
View File


+ 352
- 0
实践6 - 异常.ipynb View File

@ -0,0 +1,352 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"实践6：异常处理\n",
"学习目标：\n",
"1.了解程序处理用户或其他系统提供的输入时可能出现预期之外的异常状况，可以使用异常处理来捕获异常并进行应急处置；\n",
"2.理解 Python 异常处理的模板含义；\n",
"3.通过例子初步了解异常处理可能的应用场景。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 实践6：异常处理"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"异常处理是个很重要，也有点难度的概念。我们先尝试理解基本的概念，后面再不断通过实践来加深掌握。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"我们前面说过，大多数程序的工作都是：接受输入，对输入进行处理，然后输出结果。这里有个很重要的理念，是所有资深程序员都习惯成自然的认知，那就是“输入是不可控的”，输入可能是用户通过键盘鼠标触控屏输入的，也可能是读取某个设备上一个程序的输出，简言之，都存在不可期的情况。\n",
"\n",
"假定我们期待用户或者某个程序给我们一个不为 0 的整数，我们要拿来做除数算出一个值，如果来的不是整数是个小数怎么办？或者就是个 0 怎么办？或者干脆就不是个数怎么办？\n",
"\n",
"还有依赖于外部设备的各种异常状况：如果我们从某个程序读一个数，但是那个程序死掉了，一直没给我们数，我们一直等着卡死在这里？或者我们要向打印机输出一个报表，但是打印机被人踢掉了电源线，一直不响应怎么办？"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"所有这些错误都在程序运行时才会出现，程序写出来是没有错的，运行时出现奇怪的异常状况，程序又没有好好处理的话，就会出现灾难，这些运行时出现的异常状况就叫**运行时错误**（*runtime error*）或者**运行时异常**（*runtime exception*）。现代编程语言一般都提供标准的异常处理方案，让我们可以写程序来处理这类异常。\n",
"\n",
"Python 提供的异常处理机制可以用下面的模板来说明：\n",
"\n",
"```python\n",
"try:\n",
" # 把有可能出现异常的代码放在 try 后面\n",
" # 当出现异常时解释器会捕获异常\n",
" # 并根据异常的类型执行后面的对应代码块\n",
" do_something_nasty()\n",
"except ValueError:\n",
" # 如果发生 ValueError 类型的异常则执行这个代码块\n",
" pass\n",
"except (TypeError, ZeroDivisionError):\n",
" # 可以一次指定几个不同类型的异常在一起处理exceptions\n",
" # 如果出现 TypeError 或者 ZeroDivisionError 则执行这个代码块\n",
" pass\n",
"except:\n",
" # 所有上面没有专门处理的类型的异常会在这里处理\n",
" pass\n",
"else:\n",
" # 当且仅当 try 代码块里无异常发生时这个代码块会被执行\n",
" pass\n",
"finally:\n",
" # 无论发生了什么这个代码块都会被执行\n",
" # 通常这里是清理性的代码，比如我们在 try 里面打开一个文件进行处理\n",
" # 无论过程中有没有异常出现最后都应该关闭文件释放资源\n",
" # 这样的操作就适合在这里执行\n",
"```\n",
"\n",
"上面出现的关键字 `pass` 的意思是“什么也不做”，Python 语法需要有点什么，但是我们暂时什么都不想做的时候放上一个 `pass` 就可以了。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"以 `try` 开始的异常处理结构可以包含所有这些模块，但并不是都必须有，但至少应该有一个 `except` 或者 `finally`。\n",
"\n",
"Python 有很多[内置的运行时错误类型](https://docs.python.org/3/library/exceptions.html#bltin-exceptions)可以直接使用，比如我们上面看到的：\n",
"* `TypeError`：当一个操作或者函数收到的参数类型不对，或者一个类型的对象不支持某个被请求的操作时抛出这个异常；\n",
"* `ValueError`：当一个操作或者函数收到的参数类型对但是值不合法时抛出这个异常；\n",
"* `ZeroDivisionError`：出现 0 作除数的情况时抛出这个异常。\n",
"\n",
"我们来看几个官方指引中的例子并稍作解释。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"while True:\n",
" try:\n",
" x = int(input('Please enter a number: '))\n",
" break\n",
" except ValueError:\n",
" print('Not a valid number. Try again...')\n",
"\n",
"print('Your number is:', x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"这里用一个无限循环中的 `input()` 方法来获取用户输入，然后把输入的字符串用 `int()` 方法转换为一个整数；如果用户没有输入一个整数，`int()` 方法会抛出一个 `ValueError`，于是执行 `except ValueError` 后面的代码块，打印一个提示，然后继续 `while True`，再次提示用户输入；如果 `try` 代码段里第一句执行成功（用户输入成功转换为整数并赋值给 x 变量），那就继续执行后面一句 `break` 终止循环，继续执行其他代码（这时候 x 里面已经有了用户输入的整数）。\n",
"\n",
"在这里异常处理确保用户输入可以转换为整数且赋值给 x，否则就不会继续执行下去，经过这样的处理，在这段代码之后我们可以相当有把握的说：x 里面有个合法的、用户输入的整数值；同时用户不管怎么乱输入也不会对程序构成致命影响，我们预期到可能出现的问题，并做了合理处理。这就是异常处理的意义所在。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def this_fails():\n",
" x = 1/0\n",
"\n",
"try:\n",
" this_fails()\n",
"except ZeroDivisionError as err:\n",
" print('Handling run-time error:', err)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"这个例子展示了用 `except ZeroDivisionError as err` 这样的语法来取得一个 `err` 对象，这个对象是系统定义的 `Exception` 类型或者子类，里面存放着发生异常时的具体上下文信息，可以打印出来也可以做别的处理。\n",
"\n",
"我们还可以从 `Exception` 派生出我们自己的异常类型，并使用 `raise` 关键字来在出现某种情况时抛出我们定义的异常，并在文档中做出清晰的说明。这样使用我们代码的其他程序员就知道什么情况是我们程序处理不了的，会抛出什么样的异常，并在调用端用捕获异常进行处理。\n",
"\n",
"建议学习 [关于 Python 异常处理的官方教程](https://docs.python.org/3/tutorial/errors.html) 来了解更多。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 案例 求直角三角形的直角边\n",
"程序实现功能为：让用户输入直角边和斜边的长度，输出第二条直角边的长度。\n",
"要求：提示用户所有的非法输入：非ASCII数字、直角边大于斜边、浮点数,并将这些非法输入所引起的异常用一个except子句匹配；异常处理完后，程序立刻终止。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import math\n",
"try:\n",
" a=int(input('直角边长度：'))\n",
" c=int(input('斜边长度：'))\n",
" print(f'直角边长度为 {a}，斜边长度为 {c}')\n",
" print(f'第二条直角边长度为：{ math.sqrt(c**2-a**2)}')\n",
"except (ValueError):\n",
" print('请使用整数，斜边必须大于直角边')\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"直角边大于斜边所产生的对负数开根号、输入非ASCII正整数这两种错误，都会引发同样的异常——ValueError。用except扑捉ValueError，输出提示信息。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 小试身手"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"1. 运行下面程序段，认识默认异常处理器，总结异常名和产生异常的场合"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
" for i in range(1,5)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for1 + i"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"12/0"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"math.sqrt(-2)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"'1'+1"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"1+'1'"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"a=5\n",
"str(a)+6"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x=10\n",
"y=2.5\n",
"f\"x={x:d},y={y:d}\""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"int('hello')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
" true+5"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"1000.1**333"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"2. 编写程序以完成如下两个表达式的计算\n",
"a/(a-b-1)\n",
"a**b\n",
"要求：a、b两变量中的数，由用户输入；它们可以是浮点数；捕捉用户的输入错误，除数不为零的错误，程序结束输出“结束”提示。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" a=float(input('a：'))\n",
" b=float(input('b：'))\n",
" print(f\"{a/(a-b-1)}\")\n",
" print(f\"{math.sqrt(a**2-b**2)}\"\")\n",
" \n",
"except_______ :\n",
" print('小学没读好？除数能为0吗？')\n",
"except _____________:\n",
" print('请使用浮点数，斜边必须大于直角边')\n",
"__________:\n",
" print(\"结束\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"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
}

Write Preview
Loading…
Cancel
Save