{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 3.8 异常处理"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3.8.1 异常 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"异常是在程序执行过程中发生的一个事件，该事件会影响程序的正常执行。 \n",
"一般情况下，在Python无法正常处理程序时或者说程序运行时候发生错误而没有被处理时就会发生一个异常。 \n",
"这些异常会被Python中的内建异常类捕捉, 异常的类型有很多，在前面的学习过程中，遇到过<font color=Red>__SyntaxError、 NameError 、TypeError、 ValueError__</font>等多个错误提示信息，这些都是异常。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 除数为0时，触发除零异常\n",
"\n",
"a = 8\n",
"b = 0\n",
"print(a / b)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 对象名字拼写错误，变量名未定义异常\n",
"\n",
"pi = 3.14 # 圆周率\n",
"diameter = 4 # 直径\n",
"area = pi * ((dimeter / 2) ** 2) # 计算圆的面积"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" 当程序发生异常时需要捕获他并进行一些处理，使其<font color=Red>__平稳结束__</font>，否则程序会终止执行甚至直接崩溃。 \n",
" 本节主要学习异常的一些处理方法和利用异常进行程序设计。 \n",
" 在程序设计过程中，要尽可能考虑全面，<font color=Red>__避免__</font>类似异常的存在，同时，尽可能对可能产生的异常进行<font color=Red>__处理__</font>，使程序具有更好的健壮性和容错性，避免程序<font color=Red>__崩溃__</font>。 \n",
" 也可以利用异常处理的方法实现程序的不同的功能。 \n",
" Python中有许多内置的异常，有一个内置异常的完整层次结构，每当解释器检测到某类错误时，就能触发相对应的异常。 \n",
" 在程序设计过程中，可以编写特定的代码，专门用于捕捉异常，如果捕捉到某类异常，程序就执行另外一段代码，执行为该异常定制的逻辑，使程序能够正确运行，这种处理方法就是异常处理。 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3.8.2 try…except子句 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"在Python中，可以使用try、except、else和finally这几个关键词来组成一个包容性很好的程序，通过 <font color=Red>__捕捉和处理异常__</font>，加强程序的 <font color=Red>__健壮性__</font>。用<font color=Red>__try__</font>可以检测语句块中的错误，从而让<font color=Red>__except__</font>语句捕获异常信息并处理。 \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"try…except语法如下： "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" <语句块1> #需要检测异常的代码块\n",
"except <异常名称1>:\n",
" <语句块2> #如果在try部份引发了异常名称1时执行的语句块\n",
"[except <异常名称2>:\n",
" <语句块3>] #如果在try部份引发了异常名称2时执行的语句块\n",
"[else:\n",
" <语句块4>] #没有异常发生时执行的语句块\n",
"[finally:\n",
" <语句块5>]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"except语句和finally语句都不是必须的，但是二者必须要有一个，否则就没有try的意义了。\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"except语句可以有多个，Python会按except语句的顺序依次匹配指定的异常。"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"1. 程序首先执行try子句\n",
" a. 如果try里面的程序没有触发异常\n",
" ⅰ. 跳过except子句\n",
" ⅱ. 执行else里面的语句\n",
" b. 如果在执行try子句的过程中发生异常\n",
" ⅰ. 根据错误类型选择执行对应的except里面的语句，这里面可以是错误信息或者其他的可执行语句。\n",
" ⅱ. except可以有多个，分别用于处理不同类型的异常\n",
" ⅲ. 每个except只捕捉一个异常，一旦捕捉到异常就不会再进入其他except语句块\n",
" ⅳ. except 子句 可以用带圆括号的元组来指定多个异常，except (RuntimeError, TypeError, NameError):\n",
" ⅴ. 如果发生的异常与 except 子句 中指定的异常不匹配，则它是一个 未处理异常，执行将终止并输出error消息。\n",
" ⅵ. except 或 else 子句执行期间也会触发异常，该异常会在 finally 子句执行之后被重新触发\n",
" c. 若有finally子句，无论是否发生异常，都执行finally语句块\n",
" ⅰ. finally放在最后，其内容通常是做一些后事的处理\n",
" ⅱ. 比如关闭文件、资源释放之类的操作\n",
" ⅲ. 如果 finally 子句中包含 break、continue 或 return 等语句，异常将不会被重新引发\n",
" ⅳ. finally语句块是无论如何都要执行的\n",
" ⅴ. 如果执行 try 语句时遇到 break,、continue 或 return 语句，则 finally 子句在执行 break、continue 或 return 语句之前执行。\n",
" ⅵ. 如果 finally 子句中包含 return 语句，则返回值来自 finally 子句的某个 return 语句的返回值，而不是来自 try 子句的 return 语句的返回值。"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdin",
"output_type": "stream",
"text": [
" 12 0\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"除数为0，不能做除法运算\n"
]
}
],
"source": [
"a, b = map(int, input().split())\n",
"\n",
"try:\n",
" import bun\n",
"except ZeroDivisionError:\n",
" print('除数为0，不能做除法运算')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 实例4.14 四则运算 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"随机产生两个整数，输出其加、减、乘、<font color=Red>__除__</font>的结果，结果为浮点数时保留小数点后2位。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"题目很简单，下面代码可以完成计算，但考虑到随机生成数字时，b的值可能会取到整数0，此时<font color=Red>__除数为0__</font>，会触发异常（小概率事件，需多次运行，但理论上一定会出现这个问题。）"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import random\n",
"\n",
"\n",
"a = random.randint(0, 20) # 随机产生一个20以内的整数\n",
"b = random.randint(0, 3) # 随机产生一个3以内的整数\n",
"sign = random.choice('+-*/') # 随机产生一个运算符号\n",
"print(f\"{a} + {b} = {a + b}\")\n",
"print(f\"{a} - {b} = {a - b}\")\n",
"print(f\"{a} * {b} = {a * b}\")\n",
"print(f\"{a} / {b} = {a / b:.2f}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"注意到0不能做除数，所以当第二个数字为0时，程序要能够对异常输入进行处理,使程序不至于因除零异常而崩溃。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"可以将<font color=Red>__可能会触发异常的语句__</font>“print(f\"{a} / {b} = {a / b:.2f}\")”放到<font color=Red>__try__</font>的语句块中，一旦触发异常，程序将执行<font color=Red>__except__</font>下面的语句块中的语句。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import random\n",
"\n",
"\n",
"a = random.randint(0, 20) # 随机产生一个20以内的整数\n",
"b = random.randint(0, 3) # 随机产生一个3以内的整数\n",
"sign = random.choice('+-*/') # 随机产生一个运算符号\n",
"print(f\"{a} + {b} = {a + b}\")\n",
"print(f\"{a} - {b} = {a - b}\")\n",
"print(f\"{a} * {b} = {a * b}\")\n",
"try:\n",
" print(f\"{a} / {b} = {a / b:.2f}\")\n",
"except ZeroDivisionError:\n",
" print('除数为0，不能做除法运算')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"此题中非常肯定的知道只有当产生的 “b”值为“0”时，才会陷入异常，这种<font color=Red>__问题明确__</font>的情况下，尽可能用<font color=Red>__if…else__</font> 语句进行处理。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import random\n",
"\n",
"\n",
"a = random.randint(0, 20) # 随机产生一个20以内的整数\n",
"b = random.randint(0, 5) # 随机产生一个5以内的整数\n",
"sign = random.choice('+-*/') # 随机产生一个运算符号\n",
"print(f\"{a} + {b} = {a + b}\")\n",
"print(f\"{a} - {b} = {a - b}\")\n",
"print(f\"{a} * {b} = {a * b}\")\n",
"if b == 0:\n",
" print('除数为0，不能做除法运算')\n",
"else:\n",
" print(f\"{a} / {b} = {a / b:.2f}\")\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Python允许在一个程序里同时对多类异常进行捕捉，触发哪个异常就执行哪个异常对应的语句。 \n",
"表3.6列出了Python中常见的异常名称及其描述，可以参考Python文档查看所有异常类及其子类。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"| 异常名称 | 描述 |\n",
"| :---- | :---- |\n",
"| Exception | 常规异常的基类，可以捕获任意异常 |\n",
"| Syntax<font color=Red>__Error__</font> | **语法**错误 |\n",
"| Name<font color=Red>__Error__</font> | 未声明/未初始化的**对象**（没有属性） |\n",
"| System<font color=Red>__Error__</font> | 一般的解释器系统错误 |\n",
"| Value<font color=Red>__Error__</font>| 传入无效的参数，或传入一个调用者不期望的值，即使值的类型是正确的 |\n",
"| Indentation<font color=Red>__Error__</font> | **缩进**错误（代码没有正确对齐） |\n",
"| Import<font color=Red>__Error__</font> | 导入模块/对象失败（路径问题或名称错误） |\n",
"| ModuleNotFound<font color=Red>__Error__</font> | 模块不存在 |\n",
"| ZeroDivision<font color=Red>__Error__</font> | 除(或取模)**零** |\n",
"| Overflow<font color=Red>__Error__</font> | 数字运算**超出**最大限制 |\n",
"| Attribute<font color=Red>__Error__</font> | 对象没有这个**属性** |\n",
"| Index<font color=Red>__Error__</font> | **索引**超出序列边界，如x只有10个元素，序号为0-9，程序中却试图访问x[10] |\n",
"| Key<font color=Red>__Error__</font> | **映射**中没有这个键(试图访问字典里不存在的键) |\n",
"| Type<font color=Red>__Error__</font> | 对类型无效的操作 |\n",
"| Tab<font color=Red>__Error__</font> | Tab和空格混用 |\n",
"| Runtime<font color=Red>__Error__</font> | 一般的**运行时**错误 |\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" import turtle # import tutle 时输出“模块名称有误”\n",
" size = eval(input())\n",
" print(size) # 参数写成sizee时会输出“变量未定义”\n",
" turtle.circle(size)\n",
" turtle.done() # done写成one时，会输出“属性不存在”\n",
"except ModuleNotFoundError: # 遇到不同类型的异常给出不同的错误提示\n",
" print('模块名称有误')\n",
"except NameError:\n",
" print('变量未定义')\n",
"except AttributeError:\n",
" print('属性不存在')\n",
"except SyntaxError:\n",
" print('存在语法错误')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Python内置了的“<font color=Red>__Exception__</font>”类可以捕捉到所有内置的、非系统退出的异常，以及所有用户定义的异常。当需要输出程序遇到的异常时，可以使用以下方法："
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" import tutle # 修改为import tutle 后运行时输出No module named 'tutle'\n",
" \n",
" size = eval(input())\n",
" print(size) # size写成sizee时输出name 'sizee' is not defined\n",
" turtle.circle(size)\n",
" # 写成circe时输出 module 'turtle' has no attribute 'circe'\n",
" turtle.done()\n",
"except Exception as e:\n",
" print(e)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3.8.3 else子句"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"没有触发异常时执行的语句"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3.8.4 finally子句 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"如果try中的异常没有在“Exception”中被指出，那么系统将会抛出默认错误代码（Traceback），并且终止程序，接下来的所有代码都不会被执行。 \n",
"但如果有<font color=Red>__finally关键字__</font>存在，则会在程序抛出默认错误代码之前，<font color=Red>__执行finally中的语句__</font>。 \n",
"这个方法在某些必须要结束的操作中颇为有用，如<font color=Red>__释放文件句柄__</font>，或<font color=Red>__释放内存空间__</font>等。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"s = ''' 静夜思\n",
" 李白\n",
"床前明月光，\n",
"疑是地上霜。\n",
"举头望明月，\n",
"低头思故乡。\n",
" '''\n",
"try:\n",
" file = open('test.txt', 'w', encoding='utf-8') # 以“写”模式打开文件\n",
" file.write(s) # 写入s中的字符串\n",
" file.seek(0) # 文件指针回到文件开头\n",
" for line in file: # 遍历逐行读文件\n",
" print(line, end='') # 逐行输出文件内容\n",
" # file.close()如果放在此处，如果前面遇到异常，将无法关闭文件\n",
"except:\n",
" print('文件读写权限错误')\n",
"finally:\n",
" file.close() # finally中的语句无论是否触发异常都会被执行，可确保文件关闭\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3.8.5 异常处理的应用 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"在一些特殊情况下，可以应用异常来实现一些特定的功能。例如正整数A+B的问题，利用其他语言实现可能需要近100行代码，而用Python结合异常处理来实现，仅需不到20行就可以实现。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 实例 4.15 正整数A+B "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"题的目标很简单，就是求两个正整数A和B的和，其中A和B都大于0。稍微有点麻烦的是，输入并不保证是两个正整数。 \n",
"输入在一行给出A和B，其间以空格分开。 \n",
"问题是A和B不一定是满足要求的正整数，有时候可能是超出范围的数字、负数、带小数点的实数、甚至是一堆乱码。 \n",
"我们把输入中出现的第1个空格认为是A和B的分隔。题目保证至少存在一个空格，并且B不是一个空字符串。 \n",
"如果输入的确是两个正整数，则按格式“A + B = 和”输出。如果某个输入不合要求，则在相应位置输出“?”，显然此时和也是“?”。"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"a, b = input().split(' ', maxsplit=1) # 根据空格切分输入为列表，切分一次\n",
"try:\n",
" a = int(a) # 列表第一个元素转整型，转换类型不成功则触发异常\n",
" if a <= 0: # 如转换成功，说明是整数，再判定是否为负数\n",
" a = '?'\n",
"except ValueError:\n",
" a = '?' # 当异常被触发时，表明不是整数，用？代替\n",
"try:\n",
" b = int(b) # 列表第二个元素转整型，转换类型不成功则触发异常\n",
" if b <= 0: # 如转换成功，说明是整数，再判定是否为负数\n",
" b = '?'\n",
"except ValueError:\n",
" b = '?' # 当异常被触发时，表明不是整数，用？代替\n",
"if a == '?' or b == '?':\n",
" print(f'{a} + {b} = {\"?\"}')\n",
"else:\n",
" print(f'{a} + {b} = {a + b}')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"虽然try...except可以捕捉和处理程序中的异常，但不能过于依赖这种方法。在程序设计过程中，首先应该尽可能排除语法错误与逻辑错误，防御性方式编码比捕捉异常方式更好，应尽量采取这种编程方式，提升性能并且使程序更健壮。 \n",
"不要试图用try语句解决所有问题，这将会极大的降低程序的性能。只有在错误发生的条件无法预知的情况下，才使用try...except进行处理。 \n",
"在程序设计过程中，一般情况下异常处理与程序主要的功能是没有关系的，过多的应用异常处理，会导致代码可读性变差。要尽量减少try/except语句块中的代码量，try语句块的体积越大, 期望之外的异常就越容易被触发，越容易隐藏真正的错误，从而带来严重后果。 \n",
"使用finally子句来执行那些无论try语句块中有没有异常都应该被执行的代码，常用于终止处理程序，这对于清理资源常常很有用，例如关闭文件。 "
]
},
{
"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.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
