【Python 入门第十八讲】Try Except的应用
原创【Python 入门第十八讲】Try Except的应用
原创
前文已经介绍过，Python 中的错误可以分为两种类型，语法错误和异常。
错误是程序中的问题，程序将因此停止执行。另一方面，当发生一些内部事件时，会引发异常，从而改变程序的正常流程。
python 中会出现两种类型的错误。
- 语法错误
- 逻辑错误（异常）
一些常见的异常错误是：
- IOError: 如果文件打不开
- KeyboardInterrupt: 当用户按下不需要的键时
- ValueError: 当内置函数收到错误的参数时
- EOFError: 如果命中文件末尾而不读取任何数据
- ImportError: 如果找不到模块
语法错误
当未遵循该语言的正确语法时，就会引发语法错误。
示例：
amount = 10000
if(amount>2999)
print("You are eligible to purchase DSA Self Paced") 输出：
File "E:\StudyPython\lesson-list\demo_list.py", line 6
if (amount > 2999)
^
SyntaxError: invalid syntax它返回语法错误消息，因为 if 语句后缺少冒号：。我们可以通过编写正确的语法来解决这个问题。
逻辑错误（异常）
在运行时中，通过语法测试后发生的错误称为异常或逻辑类型。例如，当我们将任何数字除以零时，会引发 ZeroDivisionError 异常，或者当我们导入不存在的模块时，会引发 ImportError。
示例 1：
marks = 10000
a = marks / 0
print(a)输出：
Traceback (most recent call last):
File "E:\StudyPython\lesson-list\demo_list.py", line 5, in <module>
a = marks / 0
ZeroDivisionError: division by zero在上面的例子中，ZeroDivisionError错误是因为我们将一个数字除以 0。
示例 2：
当缩进不正确时。
if(a<3):
print("gfg") 输出：
File "E:\StudyPython\lesson-list\demo_list.py", line 2
print("gfg")
^
IndentationError: expected an indented block除上述例外情况外，一些常见的内置异常情况包括：
Exception | 描述 |
|---|---|
IndexError | 当检索到列表的错误索引时。 |
AssertionError | 语句失败时发生 |
AttributeError | 当属性分配失败时，会发生此事件。 |
ImportError | 当找不到导入的模块时，会发生此事件。 |
KeyError | 当找不到字典的键时，会发生这种情况。 |
NameError | 当变量未定义时，会发生这种情况。 |
MemoryError | 当程序内存不足时，就会发生这种情况。 |
TypeError | 当函数和操作以不正确的类型应用时，会发生这种情况。 |
错误处理
使用 try/except/finally 处理异常
我们可以通过 Try/Except/Finally 方法处理错误。我们在 try 中编写不安全的代码，在 except 中编写回退代码，在 finally 块中编写最终代码。
示例：
try:
print("code start")
print(1 / 0)
except:
print("an error occurs")
finally:
print("Tencent") 
引发预定义条件的异常
当我们想对某些条件的限制进行编码时，我们可以引发异常。
示例：
try:
amount = 1999
if amount < 2999:
raise ValueError("please add money in your account")
else:
print("You are eligible to purchase XXX")
except ValueError as e:
print(e)
Try Except
Try 和 Except 语句用于在 Python 代码中处理这些错误。try 块用于检查某些代码是否存在错误，即当程序中没有错误时，try 块内的代码将执行。而 except 块中的代码将在程序在前面的 try 块中遇到某些错误时执行。
语法：
try:
except:try 是如何工作的
- 首先，执行 try 子句，即 try 之间的代码。
- 如果没有异常，则只有 try 子句将运行，除非子句已完成。
- 如果发生任何异常，将跳过 try 子句，并且将运行 except 子句。
- 如果发生任何异常，但代码中的 except 子句不处理它，则会将其传递给外部 try 语句。如果异常未得到处理，则执行将停止。
- try 语句可以有多个 except 子句
示例 1：
没有异常，因此 try 子句将运行。
def divide(x, y):
try:
result = x // y
print("Yeah ! Your answer is :", result)
except ZeroDivisionError:
print("Sorry ! You are dividing by zero ")
divide(3, 2)
示例 2：
存在异常，因此只有 except 子句才会运行。
def divide(x, y):
try:
result = x // y
print("Yeah ! Your answer is :", result)
except ZeroDivisionError:
print("Sorry ! You are dividing by zero ")
divide(3, 0)
示例 3：
除语句外的另一种编写方式如下所示，通过这种方式，它只接受您要捕获的异常，或者您可以检查发生了哪个错误。
# code
def divide(x, y):
try:
# 只给出小数部分作为答案
result = x // y
print("Yeah ! Your answer is :", result)
except Exception as e:
# 通过这种方式，我们可以知道发生错误的类型
print("The error is: ",e)
divide(3, "GFG")
divide(3,0)
Else语句
在 Python 中，您还可以在 try-except 块上使用 else 子句，该子句必须在所有 except 子句之后存在。仅当 try 子句未引发异常时，代码才会进入 else 块。
语法：
try:
# 一些代码
except:
# 如果try块中出现错误，则执行
else:
# 如果没有异常，则执行示例：
def AbyB(a , b):
try:
c = ((a+b) // (a-b))
except ZeroDivisionError:
print ("a/b result in 0")
else:
print (c)
AbyB(2.0, 3.0)
AbyB(3.0, 3.0)
Python 中的 Finally 关键字
Python 提供了一个关键字 finally，它总是在 try 和 except 块之后执行。最终块始终在 try 块正常终止后执行，或者在 try 块因某些异常而终止后执行。
语法：
try:
# 一些代码
except:
# 在 try 块中发生错误时执行
else:
# 如果没有异常，则执行
finally:
# 一些代码...（始终执行）示例：
# try 块中没有引发异常
try:
k = 5//0
print(k)
# 处理除零异常
except ZeroDivisionError:
print("Can't divide by zero")
finally:
# 无论是否引发异常，此块始终执行
print('This is always executed')
Python 中自定义的异常
通过示例介绍如何在 Python 中定义自定义异常。
示例：
class CustomError(Exception):
pass
raise CustomError("Python 中自定义异常的示例")
# 输出：CustomError: Python 中自定义异常的示例当代码出错时，Python 会抛出错误和异常，这可能会导致程序突然停止。Python 还借助 try-except 提供了异常处理方法。一些最常见的标准异常包括 IndexError、ImportError、IOError、ZeroDivisionError、TypeError 和 FileNotFoundError。
自定义异常
异常需要直接或间接地从 Exception 类派生。虽然不是强制性的，但大多数异常都以“错误”结尾的名称命名，类似于 python 中标准异常的命名。例如
# 一个用于创建用户定义异常的 Python 程序
# 类 MyError 派生自超类 Exception
class MyError(Exception):
# 构造函数或初始化器
def __init__(self, value):
self.value = value
# __str__ 用于打印() 值
def __str__(self):
return(repr(self.value))
try:
raise(MyError(3*2))
# 异常的值存储在 error 中
except MyError as error:
print('发生了一个新异常: ', error.value)
help自定义
help(Exception)
输出：
E:\StudyPython\venv\Scripts\python.exe E:\StudyPython\lesson-list\demo_list.py
Help on class Exception in module builtins:
class Exception(BaseException)
| Common base class for all non-exit exceptions.
|
| Method resolution order:
| Exception
| BaseException
| object
|
| Built-in subclasses:
| ArithmeticError
| AssertionError
| AttributeError
| BufferError
| ... and 15 other subclasses
|
| Methods defined here:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from BaseException:
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setattr__(self, name, value, /)
| Implement setattr(self, name, value).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
进程已结束,退出代码0示例 1：
具有多重继承的用户定义类
在下面的文章中，我们创建了一个名为“Error”的类，该类派生自 Exception 类。此基类由各种用户定义类继承，以处理不同类型的 python 引发异常并带有消息
# 定义 Python 用户自定义异常
class Error(Exception):
"""其他异常的基类"""
pass
class zerodivision(Error):
"""当输入值为零时引发"""
pass
try:
i_num = int(input("请输入一个数字："))
if i_num == 0:
raise zerodivision
except zerodivision:
print("输入值为零，请重试！")
print()示例 2：
从超类异常派生错误
当模块需要处理多个不同的错误时，会创建超类异常。执行此操作的常见方法之一是为该模块定义的异常创建基类。此外，还定义了各种子类，以便为不同的错误条件创建特定的异常类。
class Error(Exception):
# 错误是 Exception 的派生类，但是
# 本模块中异常的基类
pass
class TransitionError(Error):
# 当操作尝试不允许的状态转换时引发
def __init__(self, prev, nex, msg):
self.prev = prev
self.next = nex
# 存储引发的错误消息
self.msg = msg
try:
raise(TransitionError(2, 3*2, "Not Allowed"))
# 异常的值存储在 error 中
except TransitionError as error:
print('Exception occurred: ', error.msg)
如何使用标准异常作为基类？
运行时错误是一个类，它是当生成的错误不属于任何类别时引发的标准异常。此程序演示如何将运行时错误用作基类，将网络错误用作派生类。以类似的方式，可以从 Python 的标准异常派生异常。
# NetworkError 基于 RuntimeError 而不是 Exception
class Networkerror(RuntimeError):
def __init__(self, arg):
self.args = arg
try:
raise Networkerror("Error")
except Networkerror as e:
print(e.args)
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。