一.匿名函数使用的一些内置方法
1. map 映射
# map的底层原理是for循环
l = [1, 2, 3, 4, 5]
# 传统方法：
# 定义一个新的变量，用来存储新的结果
# new_l = []
# for i in l:
# new_l.append(i ** 2)
# print(new_l)
# 使用map
# def index(x):
# return x ** 2
res = list(map(lambda x: x ** 2, l))
print(res)
2. zip 拉链
l1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
l2 = ['ly', 'jason', 'tom', 'kevin', 'tony', 'Pony']
l3 = ['a', 'v', 'b', 'c', 'd']
l4 = [111,222,333]
# [(1, 'ly'), (2, 'jason')...]
# 传统做法：
# 定义一个变量， 存储结果
# new_l = []
# for i in range(len(l1)):
# new_l.append((l1[i], l2[i]))
# print(new_l)
# zip
res = list(zip(l1, l2, l3,l4))
print(res)
3. max最大，min最小
# max,min
# l = [1, 2, 3, 4, 66,77,8,99,]
# l.sort()
# print(l[-1])
# print(l[len(l)-1])
# print(max(l))
# print(min(l))
d = {
'ly': 9999999,
'jason': 1000,
'kevin': 2000,
'tom': 20
}
'''
字典暴露的是k值，
按照ASCII码对应的十进制比较
A:65
a:97
0:48
'''
# def index(key):
# return d[key]
# max函数返回什么值就按照什么值进行比较， 返回结果还是字段的k
# print(max(d, key=index)) # 底层也是for循环
print(max(d, key=lambda key:d[key])) # 底层也是for循环
print(min(d, key=lambda key:d[key])) # 底层也是for循环
4. filter 过滤
# 传统做法
new_l = []
# for i in l:
# if i > 30:
# new_l.append(i)
#
# print(new_l)
# def index(k):
# return k > 30
print(list(filter(lambda x: x > 30, l, )))二.可迭代对象
# 迭代：即更新换代，每一次要依赖于上一次的结果
# 可迭代对象：
内置有__iter__()方法的都是可迭代对象
内置的意思是可以点出来的
a = 1 # 不是
b = 1.22 # 不是
c = 'hello' # 是
d = [1, 2, 3, 4] # 是
f = (1, 2, 3, 4) # 是
h = {'username': 'ly'} # 是
i = {1, 2, 3, 4} # 是
j = True # 不是
k = open('a.txt', 'w', encoding='utf-8') # 是
"""
有__iter__()的数据类型：
字符串，列表，元祖，字典，集合，文件
"""
print(c.__iter__())
print(h.__iter__())
print(d.__iter__())
# 另外一种简便写法
print(iter(c))
print(iter(h))
print(iter(d))
len(c)
c.__len__()
'''
c.__iter__()方法也有另外一种简单写法 iter()
所有的__开头的方法都有一个简单写法：函数名()
'''三.迭代器对象
# 什么是迭代器对象
内置有__iter__(),并且也要拥有__next__方法的才是迭代器对象
# 如何生成迭代器对象？
让可迭代对象调用__next__()
# 迭代器的作用：
提供了一种不依赖于索引取值的方式
c = 'hello' # 是
d = [1, 2, 3, 4] # 是
f = (1, 2, 3, 4) # 是
h = {'username': 'ly'} # 是
i = {1, 2, 3, 4} # 是
# 文件对象本省就是可迭代对象和迭代器对象
k = open('a.txt', 'w', encoding='utf-8') # 是
res = c.__iter__()
# res.__next__() # 迭代器对象
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())
# res2 = d.__iter__()
# print(res2.__next__())
# print(res2.__next__())
# print(res2.__next__())
# print(res2.__next__())
# print(res2.__next__())
# res1 = d.__iter__()
# res1.__next__() # 迭代器对象
# res2 = k.__iter__()
# res2.__next__()
# k.__next__()
#练习题：1
# 对应一个可迭代对象，可以连续多次__iter__(),得到的结果还是本身
# res2 = d.__iter__()
# print(res2.__next__())
# 练习题2：
# a = d.__iter__()
# print(a.__next__())
# a = d.__iter__()
# print(a.__next__())
print(d.__iter__().__next__())
print(d.__iter__().__next__())
print(d.__iter__().__next__())
print(d.__iter__().__next__())四.for循环内部原理
l = [1, 2, 3, 4, 5]
# 循环打印出每一个元素，不能使用for循环，还有使用__next__
# res = l.__iter__()
# while True:
# print(res.__next__())
for i in l:
print(i)
'''
for循环的原理：
1. 先把in后面的可迭代对象__iter__()
2. 调用__next__取值
3. 当值取完之后，for内部自定帮你把异常处理了
'''
res = l.__iter__()
while True:
# 检测的代码
print(res.__next__())
# 如果有错，处理掉五.异常捕获
# 什么是异常？
异常就是错误发生的信号，如果不对该信号做处理，那么，之后的代码都不能正常执行
异常的分类：
语法错误：
print(123
不允许出现，出现之后，立马修改
逻辑错误
l = [1, 2, 3]
print(l[5])
逻辑错误允许出现，但是，一般情况，逻辑错误要写到尽量完美
异常的三大部分：
Traceback：
错误发生的位置
xxxError:
错误类型
xxxError:后面的内容：
错误发生的原因
# 如何解决异常信息呢？
'''
语法结构：
try:
被检测的代码
except 错误类型:
print('')
except 错误类型:
print('')
except 错误类型:
print('')
'''
try:
# 写可能会报错的代码
# l = [1,2,3,4]
# l[6]
# 1/0
d = {'username': 'aaa'}
d['aaa'] # KeyError
except IndexError as e:
print(e)
# except ZeroDivisionError as e:
# print(e)
# except KeyError as e:
# print(e)
except Exception as e:
print(e)
l = [1, 2, 3, 4, 5]
# 循环打印出每一个元素，不能使用for循环，还有使用__next__
res = l.__iter__()
while True:
try:
print(res.__next__())
except Exception as e:
break
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
