异常处理、生成式对象

1.异常常见类型

SyntaxError:语法错误
NameError:名字错误，一般由于变量名未定义造成
IndexError:索引错误，列表的索引值超过了范围
KeyError:字典键错误，字典的键找不到
IndentationError:缩进错误

2.异常处理语法结构

1.基本语法结构:
    try:
        待监测的代码(可能会出错的代码)
    except 错误类型:
        针对上述错误类型指定的方案
        
try:
    print(name)
except NameError:
    print('变量名没有定义就使用了')  # 变量名没有定义就使用了
"""
如果except后面的错误类型正确，那么就不会报错，而是直接执行except的子代码，错误类型不对还是会报错
"""    
        
2.查看错误信息:
    try:
        待监测的代码(可能会出错的代码)
    except 错误类型 as e:
        针对上述错误类型指定的方案
try:
    print(name)
except NameError as e:
    print('变量名没有定义就使用了')
    print(e)  # 变量名没有定义就使用了 name 'name' is not defined
"""
加一个参数e可以查看具体错误，也可以加上其他代码
"""

3.针队不同的错误类型制定不同的解决方案
	 try:
        待监测的代码(可能会出错的代码)
    except 错误类型1 as e:
        针对上述错误类型指定的方案
    except 错误类型2 as e:
        针对上述错误类型指定的方案
    except 错误类型3 as e:
        针对上述错误类型指定的方案
        
try:
    print(name)
    l1 = [1, 2, 3, 4]
    l1[5]
except IndexError as e:
    print(e)
except NameError as e:
    print(e)
except KeyError as e:
    print(e)  # name 'name' is not defined
"""
如果不确定是哪种错误类型，可以采用上面的格式。但是该形式找到地一个错误类型之后就会停止运行，也就是说运行一次只能找到一处错误
"""

4.万能异常
try:
    待监测代码(可能会出现的代码)
except Exception as e:
    针队各种常见的错误类型全部统一处理

try:
    print(name)
    l1 = [1, 2, 3, 4]
    l1[5]
except Exception as e:
    print(e)  # name 'name' is not defined
"""
一次只能检测一处错误
"""

5.结合else使用:被监测代码没有错误时执行else子代码
try:
    待监测的代码(可能会出现错误的代码)
except Exception as e:
    针队各种常见的错误类型全部统一处理
else:
    try的子代码正常运行结束没有任何的报错后 再执行else子代

try:
    # print(name)
    l1 = [1, 2, 3, 4]
    # l1[5]
except Exception as e:
    print(e)
else:
    print('没有其他错误了')  # 没有其他错误了
    
6.结合finally使用:
    try:
        待监测的代码(可能会出现错误的代码)
    except Exception as e:
        针队各种常见的错误类型全部统一处理
    else:
        try的子代码正常运行结束没有任何的报错后 再执行else子代
	 finally:
        无论try子代码是否报错，最后都要执行finally子代码 
try:
    print(name)
except Exception as e:
    print(e)
else:
    print('没有错误了')
finally:
    print('嘿嘿嘿')  # name 'name' is not defined 嘿嘿嘿

try:
    name = 'jason'
    print(name)
except Exception as e:
    print(e)
else:
    print('没有错误了')
finally:
    print('嘿嘿嘿')  # jason 没有错误了 嘿嘿嘿

3.异常处理补充

1.断言:关键字assert，后面的代码如果是对的那么会执行下面的代码，是错的直接会报错
info = 'jerry'
assert isinstance(info, str)
print('看我是否会执行')  # 看我是否会执行

info = 'jerry'
assert isinstance(info, int)
print('看我是否会执行')  # 报错	

2.主动抛异常:如果不满足条件则会执行else分支结构,满足条件则直接报错
name = 'max'
if name == 'max':
    raise Exception('如果是max则执行我')
else:
    print('name不是max才执行我')  # 执行结果:报错
    
name = 'jason'
if name == 'max':
    raise Exception('如果是max则执行我')
else:
    print('name不是max才执行我')  # name不是max才执行我

4.异常处理实战应用

1.异常处理能尽量少用就少用
2.被try监测的代码能尽量少就尽量少
3.当代码中可能会出现一些无法控制的情况报错才应该考虑使用
	eg: 使用手机访问网络软件 断网
      编写网络爬虫程序请求数据 断网

练习:使用while循环+异常处理+迭代器对象 完成for循环迭代取值的功能
l1 = [11, 22, 33, 44, 55, 66, 77, 88, 99]
new_l1 = l1.__iter__()
while True:
    try:
        print(new_l1.__next__())
    except Exception as e:
        break

5.生成器对象

1.本质:
    内置有__iter__和__next__的迭代器对象
    
2.区别:
    迭代器对象是解释器自动提供的，由数据类型，文件对象转变为迭代器对象。
    生成器对象是程序员编写出来的
    
3.创建生成器的基本语法:函数团体代码中填写yield关键字
"""
1.函数体代码中如果有yield关键字，那么函数名加括号不会执行函数体代码，而是会生成一个生成器对象(迭代器对象)
"""
def my_iter():
    print('生成器就是迭代器的一种')
    yield 
my_iter()
"""
2.把加括号的结果赋值给一个变量名，变量名调用__next__才会执行函数体代码
"""
def my_iter():
    print('生成器就是迭代器的一种')
    yield
my_iter()
res = my_iter()
res.__next__()
"""
3.多加一个res.__next___()会报错，因为执行一次代码会停在yield后面(类似鼠标的移动)，下次基于该位置再继续往下找第二个yield
"""
def my_iter():
    print('生成器就是迭代器的一种')
    yield
    print('生成器就是迭代器的一种111')
    yield
    print('生成器就是迭代器的一种222')
    yield
my_iter()
res = my_iter()
res.__next__()
res.__next__()
res.__next__()  # 生成器就是迭代器的一种 生成器就是迭代器的一种111 生成器就是迭代器的一种222
"""
4.yield类似return，可以有返回值
"""
def my_iter():
    print('生成器就是迭代器的一种')
    yield 0
    print('生成器就是迭代器的一种111')
    yield 111
    print('生成器就是迭代器的一种222')
    yield 222
my_iter()
res = my_iter()
res1 = res.__next__()
print(res1)
res2 = res.__next__()
print(res2)
res3 = res.__next__()  
print(res3)  # 生成器就是迭代器的一种 0 生成器就是迭代器的一种111 111 生成器就是迭代器的一种222 222

6.自定义生成器range()功能

1.两个参数:
def index(start_num, end_num):
    while start_num < end_num:
        yield start_num
        start_num += 1

for i in index(1, 10):
    print(i)
"""
深层原理:
res = index(1, 10).__iter__()
while True:
    try:
        print(res.__next__())
    except Exception:
        break
"""

        
2.一个参数
"""
for i in range(10)代表10是end_num，所以要首先把10传给第二个参数，再把第一个参数变成0
"""
def my_range(start_num, end_num=None):
    if not end_num:
        end_num = start_num
        start_num = 0
    while start_num < end_num:
        yield start_num
        start_num += 1

for i in my_range(10):
    print(i)
    
3.三个参数
def my_len(start_num, end_num=None, step=1):
    if not end_num:
        end_num = start_num
        start_num = 0
    while start_num < end_num:
        yield start_num
        start_num += step


for i in my_len(1, 10, 2):
    print(i)

7.yield冷门用法

如果yield后面有值，函数体代码会执行到yield行并且返回yield后面的值，如果yield前面有变量名和赋值符号，通过send给此变量名传值，调用一次相当于调用一次双下next
def eat(name, food=None):
    print(f'{name}准备用餐')
    while True:
        food = yield
        print(f'{name}正在吃{food}')

res = eat('jason')  # 变成一个生成器
res.__next__()  # 执行函数体代码
res.send('汉堡')
res.send('包子')

8.生成器表达式

列表生成式:
l1 = [i*3 for i in range(1, 10)]
print(l1)  # [3, 6, 9, 12, 15, 18, 21, 24, 27]

元组生成器:组成一个新元组时直接打印变量名是一个内存地址，用for循环才能得到元组中的值
t1 = (i*3 for i in range(1, 10))
print(t1)  # <generator object <genexpr> at 0x00000284A176F190>
for i in t1:
    print(i)
    
"""
面试题:
"""
def add(n, i):  # 1.普通函数 返回两个数的和  求和函数
    return n + i
def test():  # 2.有yield关键字，定义生成器
    for i in range(4):
        yield i
g = test()  # 3.激活生成器
for n in [1, 10]:  # 4.第一次n=1  5.第二次n=10
    g = (add(n, i) for i in g)  # 5.第一次g = (add(1, i) for i in g)
    #  6.g = (add(10, i) for i in (add(10, i) for i in g))
    """
    第一次for循环
        g = (add(n, i) for i in g)
    第二次for循环
        g = (add(10, i) for i in (add(10, i) for i in g))
    """
res = list(g)  # 7.list(g)相当于for循环
print(res)
"""
1.add(n, i)就是一个普通的求和函数，test()中含有yield关键字，所以g = test()产生了一个生成器对象。
2.生成器对象的特点就是惰性，不进行迭代就不运算。迭代有以下几种方式: 
    2.1for循环，for循环的本质就是调用了__iter__和__next__方法进行了迭代
    2.2调用__next__方法
    2.3调用send方法
    2.4数据类型强制转换，比如使用list()强制转换(相当于是对其进行for循环)
    
3.对n进行for循环时，第一次n=1，生成器没有迭代，所以i没有值，第二次n=10，同样i没有值。
第一次:g = (add(n, i) for i in g)(拿不到值就不会执行，所以n=1放进去没有意义，n就是一个变量名)，g=test()，所以g = (add(n, i) for i in test())
第二次:g = (add(n, i) for i in (add(n, i) for i in test()))，此时for循环结束，结束时n=10

4.此时list(g)，生成器对象开始执行，test()的返回值i循环了4次，分别是0,1,2,3，这4个值被g表达式中的i接收，所以add(n,i)的值是10,11,12,13

5.此时for i in (add(n, i) for i in test())，i拿到的值是20,21,22,23。对其循环拿到的值就是20,21,22,23。
"""