02-python 基础语法知识-04-异常与错误处理

最新推荐文章于 2022-01-28 18:21:42 发布

阿常呓语

最新推荐文章于 2022-01-28 18:21:42 发布

阅读量383

点赞数 2

分类专栏：和我一起学习Python3 基础文章标签：异常 exception

本文链接：https://blog.csdn.net/u010339879/article/details/105301261

版权

和我一起学习Python3 基础专栏收录该内容

17 篇文章 3 订阅

订阅专栏

本文深入探讨Python中的异常处理机制，包括异常的概念、如何捕获和处理异常、自定义异常的创建，以及如何利用异常进行流程控制。文章还介绍了如何安装和查看第三方包自定义的异常，帮助读者更好地理解和应对程序中的错误。

摘要由CSDN通过智能技术生成

文章目录

02-python 基础语法知识-04-异常与错误处理

02-python 基础语法知识-04-异常与错误处理

总体要讲的大纲内容如下

循环- for while
流程中断 continue break
逻辑操作 and ,or ,not
函数
常用内置函数 (todo)
python中的异常与错误处理

今天我们开始学习一个比较关键的一个概念叫异常。你可能没有接触过什么叫异常,它是所有编程语言都比不可少的话题。程序有时候并没有我们想象的那么强大，有时候也会出现一些报错，导致程序停止了。这些报错我们就称为程序抛出了一个异常。

什么是异常

简单理解就是我们说在代码执行的时候发生了错误，这个时候就产生了一个异常，程序就被迫中断了。

不知道我们之前介绍的一些基础的数据类型，我会说某某方法如果怎么样，就报错 IndexError 。这些报错就是异常，当异常发生的时候，如果我们采取任何措施，程序将会停止运行。

举几个常见的报错的例子

>>> nums = ["one", "two", 'three', 'four', 'five']
>>> nums[10]
Traceback (most recent call last):
  File "<input>", line 1, in <module>
IndexError: list index out of range

IndexError 这里就是一个异常，这个异常发生在访问了一个不存在的位置，python 解释器不知道如何做，所以就报错了。

>>> 'frank'.index('name')
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: substring not found

ValueError 是一个异常，这里想在在字符串中寻找一个子串name 发现没有找到，也报错了。这里就是抛出了一个异常 .

>>> 1/0
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ZeroDivisionError: division by zero

ZeroDivisionError 这里也报错了，这里很明显 1 是不能除以0 的，这个一般人都知道。所以你强行给计算机算这个值，python解释器也没有办法算出来。这个也会抛出异常。 ZeroDivisionError

>>> 
... person = {
...     'weight': 60,
...     'name': 'frank',
...     'height': 165,
...     'hobby': 'swimming'
... }
>>> 
>>> person['aaa']
Traceback (most recent call last):
  File "<input>", line 1, in <module>
KeyError: 'aaa'

在字典中强行访问不存在的key , 这个时候 python 解释器也不知道如何处理，然后也报错了。这次报错叫 KeyError .

上面的这些例子都叫异常。而且不同的报错有不同的异常。也就是异常是可以分类的。就是有不同类型的异常，通过不同的异常，我们可以大概知道程序发生了什么问题。方便我们更好的排查问题。

异常发生时会发生什么？

当异常发生的时候，程序就会中断，之后的代码将不会执行。

def operate():
    print("operate begin")

    nums = ["one", "two", 'three', 'four', 'five']
    print(nums[1])

    # 这里要发生异常
    print(nums[10])

    print(nums[-1])  #1
    print("operate end") #2


operate()

运行这段代码看看会发生什么，这个函数一开始先打印 index=1 元素，然后打印index=10的元素，显然不存在，之后打印最后一个元素。最后输出一句话代表函数结束了。

来看下运行结果

operate begin
two
Traceback (most recent call last):
  File "C:/Users/changfx/PycharmProjects/python-study/myerror.py", line 20, in <module>
    operate()
  File "C:/Users/changfx/PycharmProjects/python-study/myerror.py", line 14, in operate
    print(nums[10])
IndexError: list index out of range

Process finished with exit code 1

从结果可以看出开始正常打印，当发生 IndexError 的报错后，程序就退出了。并没有执行后面的语句。

没有打印最后的结束语，也没有打印最后一个元素。

总结一下：当异常发生的时候，如果我们没有对异常进行处理。程序就中断，然后程序就会异常的退出了。

如何处理异常

try except finally else

可以通过这个来捕获可能发生的异常。

try:
    pass
	# 可能发生异常的代码段
except IndexError as e:
    pass

来修改一下上面的函数

def operate():
    print("operate begin")

    nums = ["one", "two", 'three', 'four', 'five']
    print(nums[1])

    try:
        # 这里要发生异常
        print(nums[10])
    except IndexError as e:
        print(e)

    print(nums[-1])
    print("operate end")


operate()

"""结果
operate begin
two
list index out of range
five
operate end

"""

再次运行这个代码，发现已经可以正常运行了。程序正常退出了，这个时候当发生异常的时候我们可以尝试捕获这个异常，只要这个异常被捕获了，那么程序就可以正常运行了。

对于异常捕获 try 语句还有其他的形式。简单说一下

有时候我们并不知道哪些代码段会发生异常，也有可能不发生异常。这个时候就要考虑用 try 把可能发生的异常进行捕获。

比如下面的函数，我想访问下标为10 的元素，但是这个array 是作为一个函数的参数传入进来，我并不知道这个array 是否有下标为10 的元素，所以我用 try 尝试捕获异常。这里我使用这种结构 .

try:
	pass
except IndexError as e:
	pass
else:
	pass

这里 else 语句代表如果没有发生异常，会执行 else 语句的内容，如果发生了异常则不会执行else 语句的内容。

def print_nums(array: list):
    print('print_nums begin')
    try:
        print(array[10])
    except IndexError as e:
        print(f"e={e}")
    else:
        print('end')

在console演示一下：

>>> def print_nums(array: list):
...     print('print_nums begin')
...     try:
...         print(array[10])
...     except IndexError as e:
...         print(f"e={e}")
...     else:
...         print('end')
... 

>>> array = list(range(5))
>>> print_nums(array)  # 发生异常
print_nums begin
e=list index out of range

>>> array2 = list(range(11))
>>> print_nums(array2) #没有发生异常 
print_nums begin
10
end

发生的异常的时候 else 的语句没有被执行，如果没有发生异常， else 的语句正常执行了。这个就是else 语句的作用。只有当 try 的代码段没有发生异常的时候， else 的语句才会被执行。

在介绍一种异常捕获的形式

finally 子句，这里 finally 的语句代表无论 try 捕获这段代码是否发生异常， finally 永远被执行。这里一般会做一些资源释放，数据库关闭连接之类的操作。

def print_nums(array: list):
    print('print_nums begin')
    try:
        # 可能发生的异常的代码段
        print(array[10])
    except IndexError as e:
        print(f"e={e}")
    else:
        print('else end')
    finally:
        print("print_nums end")

在 console 演示

>>> def print_nums(array: list):
...     print('print_nums begin')
...     try:
...         # 可能发生的异常的代码段
...         print(array[10])
...     except IndexError as e:
...         print(f"e={e}")
...     else:
...         print('else end')
...     finally:
...         print("print_nums end")
...         
>>> 

>>> print_nums(array=list(range(11)))  # 不会发生异常
print_nums begin
10
else end
print_nums end


>>> print_nums(array=list(range(5)))  # 会发生异常
print_nums begin
e=list index out of range
print_nums end

可以看出无论发生或者不发生异常，都会执行 finally 子句的代码段。这个就是 finally 的作用。

如何自己主动抛出一个异常

可以使用 raise 语句抛出一个异常. 这里可以用来检测一些用户输入，如果输入了一些不合法的值，我们就可以主动抛出一个异常。给出用户一些错误提示信息。

raise IndexError("xxxxxxx")

手动抛出一个异常，比如人的年龄不可能超过 100,和小于0 。这里手动抛出一个 ValueError 的异常

>>> 
>>> 
... age = 150
... if age > 100 or age < 0:
...     raise ValueError("age >100 or age<0 ")
... 
Traceback (most recent call last):
  File "<input>", line 4, in <module>
ValueError: age >100 or age<0

你注意到了吗? 这里我抛出的异常是 ValueError , 而不是 KeyError ,IndexError 。所以这里要提醒一下，异常是有分类的，每一种异常都有特定的含义，你需要了解这些特定含义，才进行抛出特定的异常。因为异常信息是用来帮助我们来排查程序出现的问题，所以抛出异常信息要尽量准确，这样才能方便排查问题。

异常的分类

在python3 中内置很多的异常，并且异常也是可以通过继承的。继承的概念属于面向对象的概念。如果不是很理解，简单理解的子承父业差不多，下面以及的异常肯定含有上面异常的所有的东西。之后我会单独解释面向对象的知识。

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StopAsyncIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError
      +-- ImportError
      |    +-- ModuleNotFoundError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- OSError
      |    +-- BlockingIOError
      |    +-- ChildProcessError
      |    +-- ConnectionError
      |    |    +-- BrokenPipeError
      |    |    +-- ConnectionAbortedError
      |    |    +-- ConnectionRefusedError
      |    |    +-- ConnectionResetError
      |    +-- FileExistsError
      |    +-- FileNotFoundError
      |    +-- InterruptedError
      |    +-- IsADirectoryError
      |    +-- NotADirectoryError
      |    +-- PermissionError
      |    +-- ProcessLookupError
      |    +-- TimeoutError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      |    +-- RecursionError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning
           +-- ResourceWarning

所有的异常都是由 BaseException 派生出来的。然后对应 4个平级的异常，我们通常情况只是从 Exception 中继承来重写自己定义的异常。这里我们经常遇见的也就10 来种左右。作为了解知道即可。

SystemExit
KeyboardInterrupt
GeneratorExit
Exception

自定义异常

我们有时候可能不需要系统系统的异常，或者满足不了我们的需要。我们通常的做法是继承 Exception 来实现自己的异常。

1.如何自定义自己的异常对象

大部分情况我们只要继承 Exception 即可。有一个关键字 class 还记得我说的，异常实际上一个类。所以我们想要实现自己的异常，一般会写一个 class 然后继承 Exception 即可。

class InvalidAge(Exception):
    pass


age = int(input("请输入你的年龄： "))
if age > 100 or age < 0:
    raise InvalidAge("你的年龄应该是 [0-100] 之间 ")

>>> class InvalidAge(Exception):
...     pass
... 
... 
... age = int(input("请输入你的年龄： "))
... if age > 100 or age < 0:
...     raise InvalidAge("你的年龄应该是 [0-100] 之间 ")
... 
请输入你的年龄： >? 123
Traceback (most recent call last):
  File "<input>", line 7, in <module>
InvalidAge: 你的年龄应该是 [0-100] 之间

异常是什么？异常是不是一种例外情况呢？

为了更好的解释异常，我举两个数字相除的例子。来看下面的两个函数

def divide(number, divisor):
    try:
        print(f"{number} / {divisor} = {number / divisor}")
    except ZeroDivisionError:
        print("You can't divide by zero ")


        
def divide2(number, divisor):
    if divisor == 0:
        print("You can't divide by zero ")
        return

    print(f"{number} / {divisor} = {number / divisor}")

这两个函数功能是相同的，计算两个数相除。应该知道除数不能作为分母。第一种方式通过捕获这个异常来提示用户不要把除数变成0 ，第二种方式是直接判断除数是否为0 。

第二种方法好不好呢？其实我不能告诉你这样做好不好。

但是对于Python 程序员更加细化追随 请求谅解，而不是许可的原则。就是说 python鼓励程序员先去做，然后在去解决问题。显然 python 是鼓励大家勇于尝试的语言，实际上看内置的库，也是遵守这个原则的。

当然还有另一种原则三思而后行的原则 这种做法也有一定好处，第一减少了不必要的cpu 的开销，减少了一些不必要执行的代码。这里对于例外情况是非常有效的。

比如说举个例子，在一个超市销售系统里面，有一个货物卖完了，显然这个时候我们应该返回什么呢？

空，缺货的字符串，一个负数？我们通过if 语句判断或取得数量显然这个逻辑写起来比较繁琐。

为啥这个时候我们不可以自定义一个异常呢？

class OutOfStack(Exception):
    pass

只要在每次用户调用购买的时候，我们try 进行捕获这段购买的逻辑。然后在购买的时候，如果判断缺货了，直接抛出这个我们自定义的异常。这样的话，是不是看起来更加好一点呢。

这里你可能对面向对象不理解，之后我们慢慢解释一下什么是面向对象编程。

class OutOfStack(Exception):
    pass

class Goods:

    def __init__(self, stock: int):
        self.stock = stock

    def purchase(self):
        if self.stock == 0:
            raise OutOfStack("库存为0,无法购买了!")
        self.stock = self.stock - 1
        print(f"购买成功。 当前库存容量：{self.stock}")

在控制台执行

>>> class OutOfStack(Exception):
...     pass
... 
... 
... class Goods:
... 
...     def __init__(self, stock: int):
...         self.stock = stock
... 
...     def purchase(self):
...         if self.stock == 0:
...             raise OutOfStack("库存为0,无法购买了!")
...         self.stock = self.stock - 1
...         print(f"购买成功。 当前库存容量：{self.stock}")
... 
>>> 
>>> goods = Goods(3)
>>> goods.purchase()
购买成功。 当前库存容量：2
>>> goods.purchase()
购买成功。 当前库存容量：1
>>> goods.purchase()
购买成功。 当前库存容量：0
>>> goods.purchase()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
  File "<input>", line 12, in purchase
OutOfStack: 库存为0,无法购买了!

当前库存为0 ，然后程序抛出一个异常。告诉用户库存不够了。

用异常来进行流程控制可以完成一些非常好用的程序设计。还有要明白，发生异常的时候并不意味着你要努力阻止这个这种情况发生。相反，它是一种无法直接交流的代码进行信息沟通的方式而已。

如何安装第三方的包？

什么是第三方包，就是一些别人觉得非常有用的功能，写成一个工具包，这样我们遇到类似问题的时候，就不要重头开始写这些工具包，直接别人写好的工具就可以了。是不是很好啊，直接窃取别人的劳动果实。哈哈，其实这就是一种开源精神。每个有追求的程序员都应该有这份追求。

那么问题来了如何寻找这些工具包呢？

有一个网站 pypi.org 所有python的第三方包都会放到这个网站上面，可以自行搜索查找。

下面我们来安装一下这几个包

celery attrs requests redis

首先你要知道这些包的名称，然后安装它。

第一种方法使用pip 工具安装

pip install package_name

打开git bash ,找到你的项目路径

$ cd python-study/
(venv)
CHANGFX@xxxxxxx ~/PycharmProjects/python-study
$ pwd
/c/Users/changfx/PycharmProjects/python-study
(venv)
CHANGFX@xxxxxx ~/PycharmProjects/python-study

# 这里是激活 虚拟环境
$ source venv/Scripts/activate
(venv)
CHANGFX@xxxxxx ~/PycharmProjects/python-study
$
(venv)
CHANGFX@xxxxxx  ~/PycharmProjects/python-study
$ pip install redis
$ pip install requests