python基础之常用内置函数&迭代器&异常捕获
一、常用内置函数：
1.map：映射 map(lambda x: x+2), l)
# map 循环获取列表中的元素并传递给匿名函数执行获取返回值
list1 = [11, 22, 33, 44, 55, 66, 77]
print(list(map(lambda x: x+2, list1))) # 循环获取列表list1中的函数传递给匿名函数在每个值上+2后返回
# 用法2：定义一个函数，把函数名和容器名传入map函数获取函数的返回值
list1 = [11, 22, 33, 44, 55, 66, 77]
def func(a):
return a+2
print(list(map(func, list1)))
2.zip：拉链 zip(l1，l2，l3)
# zip 用于按照位置取每个列表中的元素组合成元组返回
l0 = [11, 22, 33, 44]
name_list = ['jason', 'kevin', 'tony', 'jerry']
l1 = [1, 2, 3, 4]
l2 = [8, 7, 6, 4]
# 用while循环实现：要求每个列表的元素数量相等
new_list = []
for i in range(len(l0)):
new_list.append((l0[i], name_list[i], l1[i], l2[i]))
print(new_list)
# 用zip内置函数实现：每个列表的元素数量可以不相等，以最少的元素为准
res = zip(l0, name_list, l1, l2)
print(list(res))
3.max：最大值 max(l)
l = [11, 22, 33, 44, 55, 66, 77]
print(max(l))
4.min：最小值 min(l)
l = [11, 22, 33, 44, 55, 66, 77]
print(min(l))
4.1 字典取最大最小值 max(dict,key= )
d = {
'jason': 3000,
'Bevin': 1000000,
'Ascar': 10000000000,
'aerry': 88888
}
# def index(key):
# return d[key]
print(max(d, key= lambda key:d[key]))
print(min(d, key= lambda key: d[key]))
5.filter：过滤
l = [11, 22, 33, 44, 55]
# 求列表l中大于30的数据
res = filter(lambda x: x > 30, l)
print(res)
6.reduce：归总
from functools import reduce # 固定句式
l = [11, 22, 33, 44, 55, 66, 77, 88, 99]
# 求列表d中所有元素的和
res = reduce(lambda x, y: x + y, l)
print(res)
res1 = reduce(lambda x, y: x + y, l, 100) # 还可以额外添加元素值
print(res1)
二、可迭代对象
迭代：即更新换代，每次的更新都依赖于上次的结果。迭代提供了一种不依赖于索引的取值方式。
可迭代对象：内置有__iter__方法的对象都是可迭代对象，内置的意思是可以通过点的方式直接查看到的。字符串、列表、字典、元组、集合、文件对象都属于可迭代对象。
双下划线的读法为：双下方法名，面对对象的时候为了与隐藏对象区分开。
__iter__可以书写为iter(),等价于调用了一个内置方法。
d.__iter__可以书写为iter(d)
可迭代对象调用__iter__方法后会变成迭代器对象。
三、迭代器对象
既含有__iter__又含有__next__方法的可迭代对象
可迭代对象调用__iter__方法后就会变成迭代器对象。
文件对象本身既是可迭代对象又是迭代器对象。迭代器对象无论执行多少次__iter__方法，结果都是一样的，还是迭代器本身。
四、for循环的本质
for循环内部原理:(for i in l:)其实for循环内部用的就是迭代：
1.将关键字in后面的数据先调用__iter__方法转为迭代器对象
2.循环执行__next__方法
3.取完之后__next__会报错,但是for循环会自动捕获该错误并处理
for循环内部原理结构：
res = 数据.iter()
while True:
检测代码是否会报错
res.next()
如果报错了则自动处理掉并结束while循环
l1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55]
# 循环打印出列表中每个元素 但是不能使用for循环:用while循环了，__next__() next()
# 1.先将列表转为迭代器对象
res = l1.__iter__() # res = iter(l1)
# 2.循环执行__next__取值
while True:
print(res.__next__()) # print(next(res))
d = {'name':'jason', 'pwd':123, 'hobby':'read'}
# 用for循环打印字典d:
for i in d:
print(i)
# 内部原理就是先把字典d用.__iter__方法转换成可迭代对象，再用while循环使用.__next__方法转换成迭代器对象取字典里面的每个k值，当取值结束后会报错，然后异常捕获处理掉。
res = d.__iter__()
while True:
try:
print(res.__next__())
except StopIteration as e:
break
五、迭代取值和索引取值对比
1.迭代取值：
优点：不依赖于索引取值的另一种取值方式。
缺点：不可以重复取值，取值的顺序永远都是固定的从左往右，如果需要重复取值只能重新定义执行。
2.索引取值：
优点：可以重复取值
缺点：需要提供有序的容器类型才可以取值（不是通用的一种取值方式）
六、异常捕获
异常：代码运行出错会导致异常 异常发生后如果没有解决方案则会导致整个程序结束。
异常三个重要组成部分：
1.traceback（错误定位）
翻到最下面从下往上的第一个蓝色字体鼠标左键点击即可跳转到错误的代码所在的行
2.XXXError （错误类型）
错误的类型
3.错误类型冒号后面的内容（错误详细内容）
错误的详细原因(很重要 仔细看完之后可能就会找到解决的方法)
异常的错误种类：
1.语法错误：不被允许，出现了应该立刻修改！
2.逻辑错误：可以被允许，出现了尽快修改！
异常处理的基本语法结构：
①一般异常语法结构：
try:
可能出现异常的代码
except 异常类型 as e: # 这里的e是错误的详细信息
应对措施（处理机制）
②万能异常语法结构：
try:
可能出现异常的代码
except Exception:
异常捕获句式和万能异常使用：
1.有可能会出现错误的代码才需要被监测
2.被监测的代码一定要越少越好
3.异常捕获使用频率越低越好
异常捕获try与else和finally连用：
try:
可能出现错误的代码
except 错误类型1 as e:
应对措施1
except 错误类型2 as e:
应对措施2
except 错误类型n as e:
应对措施n
else:
以上错误都不出现的情况下走这里
finally:
无论异常走不走，都会走这里
了解一下：断言用法：assert isinstance（）
name = 'jason'
assert isinstance(name,str)
主动报异常：raise
raise 错误类型
