关于Python异常处理,看这一篇就够了

2020/06/11 16:59 · python教程 ·  转载文章 · 104阅读 · 0评论

当我们用Python编程的时候,常常会出现很多错误,大多数是语法错误,当然也有一些语义错误。例如,我就经常忘记在if语句后面加冒号,然后运行的时候就会报错如下所示。

>>> if 5 % 2 == 1
  File "<stdin>", line 1
    if 5 % 2 == 1
                ^
SyntaxError: invalid syntax

如果我们使用Pycharm等IDE来写代码的时候,这种低级的语法错误会被IDE用红色波浪线标注出来,会比较方便我们解决这些错误。

但是,除了这些错误,我们写Python代码的时候也很可能包含一些逻辑上的错误,例如TypeError就是我们经常遇到的一种错误,它表示数据类型不匹配。

>>> "This year is " + 2020 + "."
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

例如上述代码从字面上理解是字符串的拼接,但是由于2020它是int整型,而不是一个字符串,不能应用于字符串的拼接。所以产生了TypeError异常。这种在Python代码执行过程中发生的非语法错误被称为异常。接下来,本文将介绍如何优雅地在Python中处理异常以及抛出异常。

1异常处理的基本形式

处理异常的标准方法就是使用try...except语句。这一点其实比较类似于Java中的try...catch语句,事实上,大部分语言都有类似的捕捉异常的方法。

通常来说,可能产生异常的代码应该被try语句囊括进去,如果报异常的就会立即停止try语句中的剩余代码,并执行except语句中的代码。

我们可以看一个简单示例

>>> # Declare a function that can handle ZeroDivisionError
>>> def divide_twelve(number):
...     try:
...         print(f"Result: {12/number}")
...     except ZeroDivisionError:
...         print("You can't divide 12 by zero.")
...
>>> # Use the function
>>> divide_twelve(6)
Result: 2.0
>>> divide_twelve(0)
You can't divide 12 by zero.

我们都知道0不能做分母,因此在上述代码中,当0为分母时就产生了一个异常。于是就执行except语句中的代码了。

2为什么要处理异常?

为什么要处理异常?因为未经处理的异常会直接中断Python程序的运行,举个例子,假如我们部署一个Python写的网站,其中一个用户的操作触发了某个Bug,导致程序产生了异常,Web服务就会直接被终止,所有用户都不能访问使用了,这显然会造成巨大损失。

>>> # Define a function without handling
>>> def division_no_handle(x):
...     print(f"Result: {20/x}")
...     print("division_no_handle completes running")
...
>>> # Define a function with handling
>>> def division_handle(x):
...     try:
...         print(f"Result: {20/x}")
...     except ZeroDivisionError:
...         print("You can't divide a number with zero.")
...     print("division_handle completes running")
...
>>> # Call the functions
>>> division_handle(0)
You can't divide a number with zero.
division_handle completes running
>>> division_no_handle(0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in division_no_handle
ZeroDivisionError: division by zero

通过上面的代码,我们也可以发现,当我们调用division_handle(0)时,由于异常得到了处理,程序还能继续运行,但是,当我们调用没有处理异常的division_no_handle(0)时,程序就直接中断了。

3变量分配

我们可以将异常赋值给一个变量,从而进一步了解该异常的相关信息,方便对该异常进行处理。例如在下面代码中,我们可以将处理后的TypeError异常赋值给变量e,并将其打印出来。

>>> # A function that show error's detail
>>> def concat_messages(x, y):
...     try:
...         print(f"{x + y}")
...     except TypeError as e:
...         print(f"Argument Error: {e}")
...
>>> # Call the function
>>> concat_messages("Hello, ", 2020)
Argument Error: can only concatenate str (not "int") to str

当然,我们也可以一次捕捉多个异常,我们将可能的异常包装在一个元组中,如下面的代码片段中所示。当我们调用函数时,我们分别触发ValueError和ZeroDivisionError。可以看到两种异常都被捕获到了

>>> # A function that handles multiple exceptions
>>> def divide_six(number):
...     try:
...         formatted_number = int(number)
...         result = 6/formatted_number
...     except (ValueError, ZeroDivisionError) as e:
...         print(f"Error {type(e)}: {e}")
...
>>> # Use the function
>>> divide_six("six")
Error <class 'ValueError'>: invalid literal for int() with base 10: 'six'
>>> divide_six(0)
Error <class 'ZeroDivisionError'>: division by zero

4异常处理语句

1,多异常语句

事实上,我们可以通过多个except子句来处理多个异常,每个子句都处理一些特定的异常。如下所示。

>>> # A function that has multiple except clauses
>>> def divide_six(number):
...     try:
...         formatted_number = int(number)
...         result = 6/formatted_number
...     except ValueError:
...         print("This is a ValueError")
...     except ZeroDivisionError:
...         print("This is a ZeroDivisionError")
...
>>> # Use the function
>>> divide_six("six")
This is a ValueError
>>> divide_six(0)
This is a ZeroDivisionError

2,else语句

我们也可以在try ... except代码块中使用else子句。不过需要注意的是,else子句需要出现在except子句之后。只有当try子句完成而没有引发任何异常时,else子句中的代码才会运行。如下例所示。

>>> # A function that has an else clause
>>> def divide_eight(number):
...     try:
...         result = 8/number
...     except:
...         print("divide_eight has an error")
...     else:
...         print(f"Result: {result}")
...
>>> # Use the function
>>> divide_eight(0)
divide_eight has an error
>>> divide_eight(4)
Result: 2.0

3,finally语句

finally子句放在块的最末尾,将在整个try…except块完成之后运行。只需要记住,无论是否产生异常,finally子句都会被执行就可以了,写法和else语句是一样的。

5

抛出异常

前面我们学习了使用try ... except块来处理Python中异常,接下来我们来看看抛出异常(产生)异常的基本形式。

>>> # Raise exceptions
>>> raise Exception
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
Exception
>>> raise NameError
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError
>>> raise ValueError()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError

如上所示,Python中使用raise关键字(Java中是throw关键字)后面跟上异常类(例如Exception,NameError)的方式来抛出异常。我们还可以使用异常类构造函数来创建实例,例如ValueError()。这两种用法没有区别,前者只是后者使用构造函数的语法糖。

1,自定义异常信息

我们还可以提供有关我们提出的异常的其他信息。最简单的方法是使用异常类构造函数,并包含适用的错误消息来创建实例。如下所示:

>>> raise ValueError("You can't divide something with zero.")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: You can't divide something with zero.
>>> raise NameError("It's silly to make this mistake.")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: It's silly to make this mistake.

2,再抛出异常
如图所示,所有异常都会在被捕获时进行处理。但是,有可能我们可以重新抛出异常并将异常传递给外部范围,以查看是否可以处理该异常。

当我们编写涉及嵌套结构的复杂代码时(例如,一个函数调用另一个函数,该函数可能会调用另一个函数),此功能会更加有用。通过再抛出异常,我们可以决定在哪里处理特定异常。当然,根据具体情况确定处理特定异常的确切位置。我们先来看一些代码:

>>> # Define two functions with one calling the other
>>> def cast_number(number_text, to_raise):
...     try:
...         int(number_text)
...     except:
...         print("Failed to cast")
...         if to_raise:
...             print("Re-raise the exception")
...             raise
...
>>> def run_cast_number(number_text, to_raise):
...     try:
...         cast_number(number_text, to_raise)
...     except:
...         print("Handled in run_cast_number")
...
>>> # Use the functions
>>> run_cast_number("six", False)
Failed to cast
>>> run_cast_number("six", True)
Failed to cast
Re-raise the exception
Handled in run_cast_number

在上面的代码中,我们有两个函数,其中run_cast_number调用另一个函数cast_number。我们使用字符串两次调用该函数,这两个函数都会导致异常,因此将显示消息“ Fasted to cast”,因为该异常是在cast_number函数中处理的。但是,第二次调用函数,我们要求cast_number函数重新引发异常,以便except子句在run_cast_number函数中运行。

3,用户自定义异常

在许多情况下,我们可以使用内置的异常来帮助我们在项目中引发和处理异常。但是,Python使我们可以灵活地创建自己的自定义异常类。也就是说,我们需要将一个类声明为内置Exception类的子类。

>>> # Define a custom exception class
>>> class FileExtensionError(Exception):
... def __init__(self, filename, desired_ext):
... self.filename = filename
... self.desired_ext = desired_ext
... def __str__(self):
... return f"File {self.filename} should have the extension: {self.desired_ext}."
...
>>> # Raise custom exceptions
>>> raise FileExtensionError
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: __init__() missing 2 required positional arguments: 'filename' and 'desired_ext'
>>> raise FileExtensionError("test.xls", "csv")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
__main__.FileExtensionError: File test.xls should have the extension: csv.

如上所示,我们创建了一个名为FileExtensionError的自定义异常类。当我们抛出这个异常时,仅使用类名是行不通的。相反,我们应该通过为构造方法设置两个位置参数来实例化此异常。通过实现__str__方法,我们可以看到自定义异常消息。换句话说,异常消息是通过调用str()函数生成的。

4, 何时应该抛出异常

一般来说,当代码可能会在某些情况下会报错无法执行时,就应该抛出异常。

您可能感兴趣的文章

本文地址:http://www.pythongcs.cn/276.html
文章标签: ,  
温馨提示:文章内容系作者个人观点,不代表Python工程狮对观点赞同或支持。
版权声明:本文为转载文章,来源于 HackDev ,版权归原作者所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

 发表评论


表情