【Python 入门第十八讲】Try Except的应用

前文已经介绍过，Python 中的错误可以分为两种类型，语法错误和异常。

错误是程序中的问题，程序将因此停止执行。另一方面，当发生一些内部事件时，会引发异常，从而改变程序的正常流程。

python 中会出现两种类型的错误。

1. 语法错误
2. 逻辑错误（异常）

一些常见的异常错误是：

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)

​

​

作者：不惑_