python_(程序结构2)

异常处理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子句，必须存在。
   如果异常没有被捕获到，会向上层(调用处)继续传递，直到程序终止运行。

"""
    异常处理
"""


def div_apple(apple_count):
    person_count = int(input("请输入人数："))
    result = apple_count / person_count
    print("每个人分得%d个苹果" % result)


# 写法1：
# try:
#     div_apple(10)
# except Exception:
#     print("出错啦")

# 写法2:
# try:
#     div_apple(10)
# except ValueError:
#     print("不能输入非整数")
# except ZeroDivisionError:
#     print("不能输入零")

# 写法3:
# try:
#     div_apple(10)
# except ValueError:
#     print("不能输入非整数")
# except ZeroDivisionError:
#     print("不能输入零")
# else:
#     print("分苹果成功啦")

# 写法4:
try:
    div_apple(10)
finally:
    print("无论对错一定执行的逻辑")

"""
    主动抛出异常
        快速传递错误信息
    # 11:25
"""


class AgeError(Exception):
    """
        封装数据
    """
    def __init__(self, message="", error_id=0, code=""):
        self.message = message
        self.error_id = error_id
        self.code = code

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

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

    @age.setter
    def age(self, value):
        if 22 <= value <= 32:
            self.__age = value
        else:
            # raise Exception("我不要")
            # raise AgeError("我不要",1001,"if 22 <= value <= 32")
            raise Exception("我不要",1001,"if 22 <= value <= 32")

# try:
#     w01 = Wife("双儿", 45)
# except AgeError as e:
#    print(e.error_id)
#    print(e.message)
#    print(e.code)

try:
    w01 = Wife("双儿", 45)
except Exception as e:
   print(e.args[0])
   print(e.args[1])
   print(e.args[2])

raise 语句
1. 作用：抛出一个错误，让程序进入异常状态。
2. 目的：在程序调用层数较深时，向主调函数传递错误信息要层层return 比较麻烦，所以人为抛出异常，可以直接传递错误信息。。
自定义异常
1. 定义：
class 类名Error(Exception):
def init(self,参数):
super().init(参数)
self.数据 = 参数
2. 调用：
try:
….
raise 自定义异常类名(参数)
….
except 定义异常类 as 变量名:
变量名.数据
3. 作用：封装错误信息
迭代
每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值。例如：循环获取容器中的元素。

"""
    迭代
    练习：exercise03
"""
list01 = [4, 3, 56, 58, 52]
for item in list01:
    print(item)
# 笔试题：
#    对象能够参与for循环的条件：
#           对象可以获取迭代器对象（对象必须具有__iter__方法）

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

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

"""
    迭代器
    练习:exercise04 05
"""
class SkillIterator:
    def __init__(self, data):
        self.__data = data
        self.__index = -1

    def __next__(self):
        self.__index += 1
        if self.__index > len(self.__data) - 1:
            raise StopIteration()
        return self.__data[self.__index]


class SkillManager:
    def __init__(self):
        self.__all_skills = []

    def add_skill(self, skill):
        self.__all_skills.append(skill)

    def __iter__(self):
        return SkillIterator(self.__all_skills)


manager = SkillManager()
manager.add_skill("降龙十八掌")
manager.add_skill("六脉神剑")
manager.add_skill("猴子偷桃")

# for item in manager:
#     print(item)

# for item in manager:
#     print(item)

iterator = manager.__iter__()
while True:
    try:
        item = iterator.__next__()
        print(item)
    except StopIteration:
        break

"""
    迭代器 --> yield
    练习:改造图形管理器
        改造MyRange类
        exercise07
    要求：调试程序

"""

class SkillManager:
    def __init__(self):
        self.__all_skills = []

    def add_skill(self, skill):
        self.__all_skills.append(skill)

    # def __iter__(self):
    #     # yield 核心逻辑： 标记
    #     # 生成迭代器代码的大致逻辑：
    #     # 1. 将yield语句以前的代码,定义到next方法体中
    #     # 2. 将yield语句以后的数据,作为到next方法返回值
    #     print("准备")
    #     yield self.__all_skills[0]
    #     print("准备")
    #     yield self.__all_skills[1]
    #     print("准备")
    #     yield self.__all_skills[2]

    def __iter__(self):
        for item in self.__all_skills:
            yield item

manager = SkillManager()
manager.add_skill("降龙十八掌")
manager.add_skill("六脉神剑")
manager.add_skill("猴子偷桃")

for item in manager:
    print(item)

# iterator = manager.__iter__()
# while True:
#     try:
#         item = iterator.__next__()
#         print(item)
#     except StopIteration:
#         break

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

def next(self):
if 没有元素:
raise StopIteration
return 聚合对象元素
3. 说明：
– 聚合对象通常是容器对象。
4. 作用：使用者只需通过一种方式，便可简洁明了的获取聚合对象中各个元素，而又无需了解其内部结构。
生成器generator
1. 定义：能够动态(循环一次计算一次返回一次)提供数据的可迭代对象。
2. 作用：在循环过程中，按照某种算法推算数据，不必创建容器存储完整的结果，从而节省内存空间。数据量越大，优势越明显。
3. 以上作用也称之为延迟操作或惰性操作，通俗的讲就是在需要的时候才计算结果，而不是一次构建出所有结果。
生成器函数
1. 定义：含有yield语句的函数，返回值为生成器对象。
2. 语法
– 创建：
def 函数名():
…
yield 数据
…
– 调用：
for 变量名 in 函数名():
语句
3. 说明：
– 调用生成器函数将返回一个生成器对象，不执行函数体。
– yield翻译为”产生”或”生成”
4. 执行过程：
(1) 调用生成器函数会自动创建迭代器对象。
(2) 调用迭代器对象的__next__()方法时才执行生成器函数。
(3) 每次执行到yield语句时返回数据，暂时离开。
(4) 待下次调用__next__()方法时继续从离开处继续执行。
5. 原理：生成迭代器对象的大致规则如下
– 将yield关键字以前的代码放在next方法中。
– 将yield关键字后面的数据作为next方法的返回值。

"""
    生成器函数
"""
"""
生成器 = 可迭代对象 + 迭代器（主要）
class Generator:
    def __iter__(self):  
        return self 
    
     def __next__(self): 
        return ... 
"""

def my_range(end):
    start = 0
    while start < end:
        yield start
        start += 1

# 循环一次  计算一次  返回一次
for item in my_range(5):
    print(item)

# range = my_range(5)
# iterator = range.__iter__()
# while True:
#     try:
#         item = iterator.__next__()
#         print(item)
#     except StopIteration:
#         break