今天的学习内容

异常处理Error

异常

1. 定义：运行时检测到的错误。
2. 现象：当异常发生时，程序不会再向下执行，而转到函数的调用语句。
3. 常见异常类型：
   – 名称异常(NameError)：变量未定义。
   – 类型异常(TypeError)：不同类型数据进行运算。
   – 索引异常(IndexError)：超出索引范围。
   – 属性异常(AttributeError)：对象没有对应名称的属性。
   – 键异常(KeyError)：没有对应名称的键。
   – 为实现异常(NotImplementedError)：尚未实现的方法。
   – 异常基类Exception。/

处理

1. 语法：
   try:
   可能触发异常的语句
   except 错误类型1 [as 变量1]：
   处理语句1
   except 错误类型2 [as 变量2]：
   处理语句2
   except Exception [as 变量3]：
   不是以上错误类型的处理语句
   else:
   未发生异常的语句
   finally:
   无论是否发生异常的语句
2. 作用：将程序由异常状态转为正常流程。
3. 说明：
   as 子句是用于绑定错误对象的变量，可以省略
   except子句可以有一个或多个，用来捕获某种类型的错误。
   else子句最多只能有一个。
   finally子句最多只能有一个，如果没有except子句，必须存在。
   如果异常没有被捕获到，会向上层(调用处)继续传递，直到程序终止运行。
   raise 语句
   1. 作用：抛出一个错误，让程序进入异常状态。
   2. 目的：在程序调用层数较深时，向主调函数传递错误信息要层层return 比较麻烦，所以人为抛出异常，可以直接传递错误信息。。
      自定义异常
   3. 定义：
      class 类名Error(Exception):
      def init(self,参数):
      super().init(参数)
      self.数据 = 参数
   4. 调用：
      try:
      ….
      raise 自定义异常类名(参数)
      ….
      except 定义异常类 as 变量名:
      变量名.数据
   5. 作用：封装错误信息

迭代

每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值。例如：循环获取容器中的元素。

可迭代对象iterable

1. 定义：具有__iter__函数的对象，可以返回迭代器对象。
2. 语法
   – 创建：
   class 可迭代对象名称:
   def iter(self):
   return 迭代器
   – 使用：
   for 变量名 in 可迭代对象:
   语句
   3. 原理：
   迭代器 = 可迭代对象.iter()
   while True:
   try:
   print(迭代器.next())
   except StopIteration:
   break

迭代器对象iterator

1. 定义：可以被next()函数调用并返回下一个值的对象。
2. 语法
   class 迭代器类名:
   def init(self, 聚合对象):
   self.聚合对象= 聚合对象

def next(self):
if 没有元素:
raise StopIteration
return 聚合对象元素
3. 说明：
– 聚合对象通常是容器对象。
4. 作用：使用者只需通过一种方式，便可简洁明了的获取聚合对象中各个元素，而又无需了解其内部结构。

异常处理

def div_apple(apple_count):
    person_count = int(input("请输入人数："))  # ValueError
    result = apple_count / person_count  # ZeroDivisionError
    print("每个人%f个苹果" % result)

# 1. 统一处理所有异常
try:
    div_apple(10)
except:
    print("出错啦")

# 2.针对不同错误，做出相应的处理逻辑
# try:
#     div_apple(10)
# except ValueError:
#     print("输入的不是整数")
# except ZeroDivisionError:
#     print("0不能作为分母")

# 3. 没有错误的逻辑 + 出错的逻辑
# try:
#     div_apple(10)
# except ValueError:
#     print("输入的不是整数")
# except ZeroDivisionError:
#     print("0不能作为分母")
# else:
#     print("没有错误的逻辑")

# 4.出错但是解决不了，可是具有必须执行的逻辑。
# try:
#     div_apple(10)
# finally:
#     print("无论是否异常，都要执行的逻辑")

print("后续逻辑")

注：异常的类型多种多样，当报出异常时程序会一层一层向上传递，上图代码可将异常压下并转入except中，并执行相应代码。

主动抛出异常 --> 快速传递错误信息

自定义异常类 --> 封装数据

class AgeError(Exception):
    def __init__(self, message="", code="", id=0):
        self.message = message
        self.code = code
        self.id = id


class Wife:
    def __init__(self, age=0):
        self.age = age

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self, value):
        if 22 <= value <= 65:
            self.__age = value
        else:
            # raise AgeError("年龄超过范围了", "if 22 <= value <=65", 1001)
            raise Exception("年龄超过范围了", "if 22 <= value <=65", 1001)

try:
    w01 = Wife(550)
# 给异常对象起一个别名
# except AgeError as e:
#     print(e.code)
#     print(e.id)
#     print(e.message)
except Exception as e:
    print(e.args[0])#年龄超过范围了
    print(e.args[1])#if 22 <= value <=65
    print(e.args[2])#1001

注：主动抛出异常可以使程序异常时不需要一层一层上报，快速获取异常信息
自定义异常则是在某些代码量大的程序中使用，通过编号快速寻找到问题所在

可迭代对象

list01 = [4, 4, 54, 56, 76]
# 迭代
for item in list01:
    print(item)

# 笔试题：
# 可以被for的条件：
#  对象具有__iter__()方法

# for循环原理
# 1. 获取迭代器
iterator = list01.__iter__()
while True:
    try:
        # 2. 获取下一个元素
        item = iterator.__next__()
        print(item)
    # 3. 如果没有元素则结束循环
    except StopIteration:
        break

注：可迭代对象iterable 与迭代器对象iterator注意区分
可迭代对象拥有__iter__方法，迭代器对象有__next__方法

for item in manager:
    print(item)

# iterator = manager.__iter__()
# while True:
#     try:
#         # 2. 获取下一个元素
#         item = iterator.__next__()
#         print(item)
#     # 3. 如果没有元素则结束循环
#     except StopIteration:
#         break

注：上图为for循环的内部机制，通过循环不断获取可迭代对象的内部数据，并在获取结束时抛出一个异常结束循环。

最后

以上就是激昂短靴为你收集整理的亿豪的python学习 day16今天的学习内容的全部内容，希望文章能够帮你解决亿豪的python学习 day16今天的学习内容所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。