lambda函数的常用方法迭代器 for循环的本质异常捕获

什么是匿名函数

lambda X：返回值

匿名函数经常和一些内置的方法来结合使用，比如：

1.map 2.zip 3.max/min 4.filter

map（）会根据提供的函数对指定的序列做映射，返回的对象是迭代器

# 让列表中的元素值，变为原来的平方
old_l = [1, 2, 3, 4, 5, 6]
# 如果用传统方法
new_l = []
for i in old_l:
    new_l.append(i ** 2)
print(new_l)

# 和lambda结合使用
new_l2 = list(map(lambda x: x ** 2, old_l))
print(new_l2)

zip（）

会将可迭代的对象作为参数，将一一对应的元素合成一个元组，返回的是由元组可以组成的列表

列表的元素数量，取决于原来长度最短的对象

1 l1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
2 l2 = ['ly', 'jason', 'tom', 'kevin', 'tony', 'Pony']
3 l3 = ['a', 'v', 'b', 'c', 'd']
4 l4 = [111, 222, 333]
5 
6 l = list(zip(l1, l2, l3, l4))
7 print(l)
8 
9 # 打印结果[(1, 'ly', 'a', 111), (2, 'jason', 'v', 222), (3, 'tom', 'b', 333)]

max（）/min()

取列表中的最大值/最小值

首字母为英文时，按照ASKII码的十进制位置比较（ASKII码序号牢记：0：48、A：65 、a：97）

 1 dic = {
 2     'ly': 9999999,
 3     'jason': 1000,
 4     'kevin': 2000,
 5     'tom': 20,
 6     '大强': 100,
 7     '小强': 200
 8 }
 9 a = max(dic)  # 字典暴露的是K值，排序的话是直接按照K值来排序的
10 print(a)  # 结果是 小强
11 b = min(dic)
12 print(b)  # 结果是 jason
13 '''将按照个人的收入来筛选大小'''
14 c = max(dic, key=lambda key: dic[key])
15 print(c)  # ly
16 d = min(dic, key=lambda key: dic[key])
17 print(d)  # tom

filter（）

指过滤，按照指定条件，过滤掉指定序列中的一些元素

1 l = [1, 2, 3, 4, 5]
2 new_l = list(filter(lambda x: x > 3, l))
3 print(new_l)

可迭代对象

　　迭代：就是更新换代，没一次都要依赖与上一次的结果

　　可迭代的对象：内置有__inter__()方法的，都是可迭代对象

　　可以内置__inter__()的数据类型，有字符串，列表，元组，字典，集合

　　补充：所有【点__函数名__ () 】方法，都有一个简单的写法【函数名（）】

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')  # 是

print(c.__iter__())
print(h.__iter__())
print(d.__iter__())
# 另外一种简便写法
print(iter(c))
print(iter(h))
print(iter(d))

len(c)
c.__len__()

迭代器对象

一个函数中，内置有__inter__（），并且也要有__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__()

迭代器练习题

# 对应一个可迭代对象，可以连续多次__iter__(),得到的结果还是本身
d = [1, 2, 3, 4]
res2 = d.__iter__().__iter__().__iter__().__iter__()
print(res2.__next__())

for循环的内部原理
        1. 先把in后面的可迭代对象__iter__()
        2. 调用__next__取值
        3. 当值取完之后，for内部自定帮你把异常处理了

异常捕获

异常就是错误发生的信号，如果不对该信号做处理，那么，之后的代码都不能正常执行
异常的分类：（1）语法错误（2）逻辑错误

逻辑错误允许出现，但是，一般情况，逻辑错误要写到尽量完美
异常的三大部分：

　　Traceback：
              错误发生的位置
       xxxError:
               错误类型
       xxxError:后面的内容：
              错误发生的原因

如何解决，获取异常信息

 1 '''
 2 语法结构：
 3     try:
 4         被检测的代码
 5     except 错误类型:
 6         print('')
 7     except 错误类型:
 8         print('')
 9     except 错误类型:
10         print('')
11 '''
12 try:
13     d = {'username': 'aaa'}
14     d['aaa']
15 except Exception as e:
16     print(e)  # 显示发生异常的代码

lambda函数的常用方法迭代器 for循环的本质异常捕获

相关

标签

lambda函数的常用方法 迭代器 for循环的本质 异常捕获

相关

标签

lambda函数的常用方法迭代器 for循环的本质异常捕获