内容概要

• 结合匿名函数一起使用的函数
• 可迭代对象
• 迭代器对象
• for循环内部本质
• 异常捕获

内容详细

常用内置函数

# 1.map() 映射
# l = [1,2,3,4,5]
# print(list(map(lambda x:x**2,l)))
# # [1, 4, 9, 16, 25]

# 2.zip() 拉链
# l = [11,22,33]
# name_list = ['jason','tom','jack']
# new_list = []
# for i in range(len(l)):
#     new_list.append((l[i],name_list[i]))
# print(new_list)
# [(11, 'jason'), (22, 'tom'), (33, 'jack')]
# 传统方法，两个列表的值数量必须一致 否则报错

# l = [11, 22, 33]
# name_list = ['jason', 'tom', 'jack']
# l1 = [1, 2, 3, 4, 5, 6, 7]
# l2 = ['q', 'w', 'e', 'r', 't', 'y', 'u']
# res = zip(l,name_list,l1,l2)
# print(list(res))
# [(11, 'jason', 1, 'q'), (22, 'tom', 2, 'w'), (33, 'jack', 3, 'e')]
# 类似于木桶效应 取短的值 然后组成列表

# 3.max与min  max求最大值 min求最小值
# l = [1, 2, 3, 4, 5, 8, 9]
# print(max(l))
# # 9
# print(min(l))
# 1

# d = {'Jason':30000,
#      'ben':8888,
#      'Amy':999,
#      'anne':1999
#      }
# # print(max(d))  # ben
# # 这样比较的是K值的第一个首字母的大小 故得到的值是错误的
# 
# print(max(d, key=lambda key: d[key]))  # Jason
# print(min(d,key=lambda key:d[key]))  # Amy
# for循环先取值 之后在比较大小
'''
A-Z  65-90
a-z  97-122
'''

# 4.filter  过滤
# l = [11, 22, 33, 44, 55]
# res = filter(lambda x: x > 30, l)
# print(list(res))  # [33, 44, 55]
# res1 = filter(lambda x: x < 30, l)
# print(list(res1))  # [11, 22]

# 5.归总
# from functools import reduce
# d = [11, 22, 33, 44, 55, 66]
# res = reduce(lambda x, y: x + y, d)
# print(res)  # 231
# res1 = reduce(lambda x,y:x+y,d,100)
# print(res1)  # 331  还可以添加其他元素值  # 100+231

可迭代对象

# 迭代
	迭代即更新换代 每次的更新都依赖于上一次的结果
    
'''迭代其实给我们提供了一种不依赖取值的方式'''

# 可迭代对象
	内置有__iter__方法的都可以称之为可迭代对象
    	内置的意思是可以通过点的方式直接查看到的
	"""
	针对双下划线开头 双下划线结尾的方式 最为专业标准的读法为双下方法		名
	面对对象的时候为了与隐藏变量区分开
	"""
    
# n = 1
# while True:
#     n += 1
#     print(n)  # 死循环

# n = 1
# while True:
#     n += 1
#     print(n)  # 死循环

# l = [11, 22, 33, 44, 55]
# n = 0
# while n < len(l):
#     print(l[n])
#     n += 1
#
# i = 12  # 没有__iter__
# f = 11.11  # 没有__iter__
# s = 'jason'  # 有__iter__
# d = {'age': 18}  # 有__iter__
# t = (11, 22, 33)  # 有__iter__
# se = {1, 2, 3}   # 有__iter__
# b = True # 没有__iter__
# file = open(r'a.txt','w', encoding='utf')  # 有__iter__
"""
含有__iter__的有
    字符串 列表 元组 集合 文件对象
上述通常为可迭代对象
"""
# print(d.__iter__())  # 等价于调用了一个内置方法  相当于d.get()
# <dict_keyiterator object at 0x0000015314C19908>
# print(iter(d))
# <dict_keyiterator object at 0x0000015314C19908>
# print(d.__len__())  # 1
# print(len(d))  # 1
"""
可迭代对象调用__iter__方法会变成迭代器对象(老母猪)

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

迭代器对象

"""
迭代器对象
	即含有__iter__方法 又含有__next__方法
如何生成迭代器对象
	让可迭代对象执行__iter__方法

文件对象本身就是可迭代对象优势迭代器对象
迭代器对象无论执行多少次__iter__方法 还是迭代器对象(本身)

迭代器给我们提供了不依赖于索引取值的方法
"""

# 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 = {'age': 18,'name':'tom'}
# res = d.__iter__()  # 转为迭代器对象
# print(res.__next__())  # age  循环取值Key
# print(res.__next__())  # name
# print(res.__next__())  # 取完元素之后再去会报错

# 易错
# d = {'username':'jason','pwd':123}
# 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循环的本质

# l = [1,2,3,4,5,6,7,8,9]
# 循环打印出列表中每个元素 但是不能使用for循环  __next__()  next()
# res = l.__iter__()
# while True:
#     print(res.__next__())  # 循环取值 取完后报错
    
# for i in l:
#     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')
# except Exception as e:
#     print('万能异常 排忧解难')

"""
异常捕获句式和万能异常
	1.有可能会出现的错误代码才需要被监测
	2.被监测的代码一定要越少越好
	3.异常捕获使用频率越低越好
"""