迭代器与异常捕获

目录

今日内容概要

  • 结合匿名函数一起使用的函数
  • 可迭代对象
  • 迭代器对象
  • for循环的内部本质
  • 异常捕获(跳过报错继续运行)
    迭代器与异常捕获

内容详细

  • 常用内置函数
1. map  映射
l = [1, 2, 3, 4]
map(lambda x:x+1, l)  # 循环获取列表中每个元素并传递给匿名函数保存返回值
print(list(map(lambda x:x+1, l)))  # 打印匿名函数保存的返回值

2. zip  拉链
l = [11, 22, 33, 44, 55, 66, 77]
name_list = ['jason', 'kevin', 'tony', 'jerry']
l1 = [1, 2, 3, 4, 5, 6, 7]
l2 = [8, 7, 6, 4, 3, 2, 1]
res = zip(l, name_list, l1, l2)
print(list(res))
# [(11, 'jason', 1, 8), (22, 'kevin', 2, 7), (33, 'tony', 3, 6), (44, 'jerry', 4, 4)]  以元素最少的数据集为主(木桶原理)

3. max 求最大值   min 求最小值
在列表中
l = [11, 22, 33, 44, 55, 66, 77]
print(max(l))  # 77 最大值
print(min(l))  # 11 最小值

在字典中
d = {
    'jason': 3000,
    'Bevin': 1000000,
    'Ascar': 10000000000,
    'aerry': 88888
}
print(max(d))  # 只会按照ASCLL代码表来比较最大值查询
'''正确写法一'''
def index(key):
    return d[key]
print(max(d,key=index))

'''正确写法二'''
print(max(d, key=lambda key: d[key]))

取最小值
print(min(d, key=lambda key: d[key]))

4. filter  过滤
l = [11, 22, 33, 44, 55]
res = filter(lambda x: x > 30, l)  # 只取符合条件的值
print(list(res))  # [33, 44, 55]

5. reduce 归总
from functools import reduce
d = [11, 22, 33, 44, 55, 66, 77, 88, 99]
res = reduce(lambda x, y: x + y, d)
res1 = reduce(lambda x, y: x + y, d, 100)  # 595 还可以额外添加元素值与列表中元素相加
print(res)  # 495 求所有数据之和

迭代器与异常捕获

  • 可迭代对象
# 迭代
	迭代即更新换代 每次更新的内容都必须依赖于上一次的结果
    '''迭代其实是给我们提供了一种可以不依赖索引取值的方式'''
    
# 可迭代对象
	内置有 _ _iter_ _ 方法的都称之为可迭代对象
	内置是可以通过.(点)语法的方式直接查看到
    '''
    针对双下划线开头结尾的方法 专业读法为:
    	双下 方法名
    在面向对象的时候为了与隐藏变量区分开
    '''

   
eg:
n = 1
while True:
    n+=1  # 迭代
    print(n)
    

l = [11, 22, 33, 44, 55, 66]
n = 0
while n < len(l):
    print(l[n])
    n += 1  # 迭代
    

    
i = 12  # 没有
f = 11.11  # 没有
s = 'jason'  # 有
l = [111,22,33,4]  # 有
d = {'username':'jason','pwd':123}  # 有
t = (11,22,33)  # 有
se = {11,22,33}  # 有
b = True  # 没有
file = open(r'a.txt','w',encoding='utf8')    
"""
含有 _ _iter_ _ 的有
	字符串 列表 字典 元组 集合 文件对象
上述通常为 可迭代对象
"""


print(d)
print(d.__iter__())  # 等价于调用了一个内置方法 d.get()
print(iter(d))  # .__iter__()简化版写法 iter(d)
print(d.__len__())
print(len(d))  # .__len__()简化版写法 len(d)
"""
可迭代对象调用了 __iter__ 方法后 会变成迭代器对象(老母猪)

 __iter__ 方法在调用时还有简化版写法 iter()
 	一般情况下 所有的双下方法都会有一个与之对应的简化版本 方法名()
"""

迭代器与异常捕获

  • 迭代器对象
"""
迭代器对象
	既含有__iter__方法 又含有__next__方法
	
如何生成迭代器
	让可迭代对象执行__iter__方法即可
	
文件对象本身既是可迭代对象又是迭代器对象
迭代器无论执行多少次__iter__方法 还是迭代器对象(本身)
"""
# 迭代器是给我们提供了不依据索引 取值的方式
i = 12  # 没有
f = 11.11  # 没有
s = 'jason'  # 有
l = [111, 222, 333, 444]  # 有
d = {'username': 'jason', 'pwd': 123}  # 有
t = (11, 22, 33)  # 有
se = {11, 22, 33}  # 有
b = True  # 没有
file = open(r'a.txt', 'w', encoding='utf8')

s = 'jason'
res = s.__iter__()  # 转成迭代器对象
print(res.__next__())  # j 迭代器对象执行__next__方法其实就是在迭代取值(for循环)
print(res.__next__())  # a
print(res.__next__())  # s
print(res.__next__())  # o
print(res.__next__())  # n

d = {'username': 'jason', 'pwd': 123}
res = d.__iter__()  # 转成迭代器对象
print(res.__next__())  # 迭代器对象执行__next__方法其实就是在迭代取值(for循环)
print(res.__next__())  # pwd
print(res.__next__())  # 取完元素之后再取会"报错"

易错
print(d.__iter__().__next__())  # username
print(d.__iter__().__next__())  # username
print(d.__iter__().__next__())  # username
print(d.__iter__().__next__())  # username
print(d.__iter__().__next__())  # username
print(d.__iter__().__next__())  # username 无论取多少次也不会报错
'''
一定要注意
	什么时候是依次往下执行(基于了上一次的结果)
	什么时候是产生了新的(跟上一次的结果无关)
'''

迭代器与异常捕获

  • for循环的本质
l1 = [1,2,3,4,5,6,7,8,9,11,22,33,44,55]
# 循环打印出列表中每个元素 但是不能使用for循环  __next__()  next()
# 1.先将列表转为迭代器对象
res = l1.__iter__()
# 2.循环执行__next__取值
while True:
    print(res.__next__())
    
# 相当于
for i in l1:
    print(i)
"""
for 循环内部原理
	1.将关键字in后面的数据先调用 __iter__方法转为迭代器对象
	2.循环执行__next__方法
	3.取完值之后__next__会报错 但是for循环会自动捕获该错误并处理
"""

迭代器与异常捕获

  • 异常捕获
# 伪代码体
"""
res = 数据.__iter__()
while True:
    检测代码是否会报错
    res.__next__()
    如果报错了则自动处理掉并结束while循环
"""

# 什么是异常
	代码运行出错会导致异常 异常发生后如果没有解决方案则会导致整个程序结束
    
# 异常三个组成部分
1. traceback
	翻到报错最下面 从下往上的第一个蓝色字体 鼠标点击 会跳转至错误的代码所在的行
2. XxxError
	错误的类型
3. 错误类型冒号后面的内容
	是错误的详细原因(错误重点 可参考来解决报错)
    
# 错误的种类
1. 语法错误
	不被允许出现 一旦出现自行立刻改正
2. 逻辑错误
	可以被允许 出现了之后尽快修改
    '''修改逻辑错误的过程 其实就是在从头到尾理清思路的过程'''
    
# 报错示例
print(idna)  # NameError

l = [11,22,33]
print(l[100])  # IndexError

d = {'username':'jason'}
print(d['xxx'])  # KeyError

int('abc')  # ValueError

异常捕获语法结构
"""
try:
	有可能出错的代码
except 错误类型 as e:
	出错之后对应的处理机制(e是错误的详细信息)
except 错误类型 as e:
	出错之后对应的处理机制(e是错误的详细信息)
except 错误类型 as e:
	出错之后对应的处理机制(e是错误的详细信息)
...
	'''出现了不同的错误 可以走不同的处理结果'''
"""
try:
    int('abc')  # 报错 ValueError: invalid literal for int() with base 10: 'abc'
except NameError as e:
    print('变量名name不存在',e)
except ValueError:  # 该报错类型只会走这里
    print('值不是纯数字')
    
# 万能异常捕获
try:
    int('abc')
    print(name)
    l = [11]
    l[100]
except Exception:
    print('你来啥都行 无所谓')
'''不论报错类型 统一执行错误处理方法'''
# 规定
"""
异常捕获句式和万能异常
1. 有可能出现错误的代码才需要被监测
2. 被监测的代码一定要越少越好
3. 异常捕获使用频率越低越好
"""

迭代器与异常捕获

上一篇:python迭代器


下一篇:C++第11课 迭代器与仿函数 (一)