程序猿大战Python——文件操作、异常、模块——常见处理异常方式

快速入门异常

==目标：==掌握异常的快速入门使用。

当程序中遇到了异常时，通常程序会出现崩溃情况。

为了不让程序崩溃，就可以使用异常来快速处理。

异常处理语法：

try:
    可能发生异常的代码
except:
    如果出现异常时, 执行的代码

说明：

try、except都是关键字，用于处理异常。

例如，一起来完成：

（1）制造出一个IndexError异常；

（2）使用异常来快速处理这段可能会产生IndexError的代码。

# 1.制造异常
# 2.处理
try:
    datas = [1,2,3]
    print(datas[100])  # 中断
except:
    print("已经发生了异常》。。")
print("11111111111111")   # 当处理了异常后,程序可以稳定继续往后执行代码

==总结：==

（1）若要让程序不崩溃，可以使用（）快速处理异常。==A、try-except==；B、try-error；

捕获多个异常

==目标：==了解捕获多个异常的使用。

捕获异常是处理异常的标准形式。通常情况下，捕获异常分为三类：

（1）捕获一个指定异常

（2）捕获多个异常

（3）捕获所有异常

接着，来看看捕获一个指定异常的语法：

try:
    可能发生异常的代码
except 异常类型名:
    当捕获到该异常类型时，执行的代码

捕获多个异常指的是：可以对一段可能发生异常的代码做多个异常类型的判断处理。

捕获多个异常语法：

try:
    可能发生异常的代码
except (异常类型1,类型2,...):
    如果捕获到该异常类型时,执行的代码

例如，一起来完成：

（1）有一段可能发生IndexError、KeyError的代码；

（2）使用多个except做异常处理；

（3）使用捕获多个异常的方式来处理代码片段。

# 1.可能发生异常
# print(1)
try:
    # print(2)
    data = [1,2,3]
    print(data[100])
    # print(3)   # 程序崩溃后的代码无法执行
    # 2.捕获
except IndexError:
# except KeyError:  # 报错: indexerror, 捕获不到异常
    print("发生了异常.")
    # print(4)
# print(5)
print("hello")
# 执行流程
# 捕获不到

# 1.可能发生异常的代码
# try:
#     # dicts = {}
#     # print(dicts["name"])
#
#     data = [1,2,3]
#     print(data[100])
#     # 2.处理异常
# # except IndexError:
# except IndexError as error:
#     print(f"可能会发生异常.=={error}")
# except KeyError:
#     print("可能会发生keyerror...")
# print("11111111111111")
​
# 升级
try:
    dicts = {}
    print(dicts["name"])
​
    data = [1,2,3]
    print(data[100])
    # 2.处理异常
# except IndexError:
except (IndexError,KeyError) as error:
# except (IndexError,KeyError,FileNotFoundError,TypeError,xxx) as error:
    print(f"可能会发生异常.=={error}")

==总结：==

（1）当捕获多个异常时，可以将多个异常使用（）形式存放。==A、元组==；B、列表。

捕获所有异常

==目标：==掌握捕获所有异常的使用。

要知道的是，Exception是表示所有程序异常类的父类，即使用Exception可以表示一切异常。

捕获所有异常语法：

try:
    可能发生异常的代码
except Exception[ as 变量]:
    当捕获到该异常类型时，执行的代码
    
   

说明：

Exception的首字母要大写。

例如，一起来完成：

（1）有一段可能发生IndexError、KeyError的代码；

（2）使用捕获所有异常的形式来处理。

# 1.可能会发生异常的代码
# 2.捕获所有异常
try:
    data = [1, 2, 3]
    print(data[100])
    dicts = {}
    print(dicts["name"])
except Exception as error:
    print(f"发生了异常信息...{error}")
print("hello world..")

==总结：==

（1）在捕获异常的三种方式中，而捕获所有异常的方式最简洁高效；

（2）在实际应用开发中，推荐使用捕获所有异常的方式来处理可能发生异常的代码。

异常的其他关键字

==目标：==了解异常其他关键字的使用。

在捕获异常过程中，有两个关键字else、finally需要注意：

else：表示如果没有异常时，要执行的代码；
finally：表示的是无论是否有异常，都要执行的代码。

当把else、finally都放入到捕获异常中，语法：

try:
    可能发生异常的代码
except 异常类型:
    当捕获到该异常类型时，执行的代码
else:
    没有异常信息时，执行的代码
finally:
    无论如何，都会执行的代码

例如，一起来完成：

（1）有一段可能发生IndexError的代码片段；

（2）使用else关键字处理不发生异常的情况；

（3）使用finally关键字处理发生、不发生异常的情况；

（4）执行程序，观察效果。

# 1.制造异常
# 2.处理 指定异常
try:
    data = [1, 2, 3]
    print(data[100])
    # print(data[0])
except IndexError:
    print("====1====已发生异常信息!")
else: # 3.else：没有发生异常时,处理的事情
    print("没有发生异常时,才会执行代码!!")
finally:# 4.finally：文件必须关闭
    print("无论如何,都会执行finally!!")

==总结：==

（1）关键字else、finally可以配合异常处理一起使用；

（2）注意：当使用finally部分代码时，可以用于完成一些必须完成的操作，例如关闭文件、关闭系统资源等。[思考]

==思考：==例如，有一段代码，当执行结束后，结果是（ ==C== ）。

def test():
    try:
        strs = "abc"
        print(strs[60])
    except:
        return 1
    finally:
        return 2

A、程序出错 B、1 C、2 D、1 2

异常具有传递性

==目标：==掌握异常可以进行传递。

例如，一起来完成：

（1）定义两个函数test()、func()；

（2）在一个函数中产生IndexError，同时在另一个函数中调用，观察效果。

# 1.func()
def func():
    print("==========A============")
    try:
        datas = [1,2,3]
        print(datas[100])
    except Exception:
        # 日志、埋点?    -->采集
        print("发生了异常信息...")   # 后台开发
    print("==========B============")

# 2.test()
def test():
    print("********1***********")
    func()
    print("********2***********")

# 3.调用test()
test()

==总结：==

（1）当一段可能发生异常的代码，发生了异常时，若不处理，则会传递给调用处；

（2）注意：标准的异常处理方式是（）。==A、捕获异常==；B、抛出异常；