匿名函数、迭代器对象

匿名函数

 匿名函数就是没有名字的函数，匿名函数也必须加括号才能调用

语法格式

#函数
def index(x):
    return x+1
#匿名函数
lambda x:x+1
#匿名函数语法格式
lambda 形参:返回值

常见的内置函数（配合匿名函数使用）

配合lambda使用的内置函数

map

ll = [1, 2, 3, 4, 5, 6, 7]
#我们现在要给这个列表中的每个元素变成元素2的次方
def index(x):
    return x**2
res=map(index,ll)
print(res) #<map object at 0x000002C8795ED080>
print(list(res))# [1, 4, 9, 16, 25, 36, 49]

#配合lambda使用
res=map(lambda x:x**2,ll)

 zip 拉链

l1 = [1, 2, 3,4,5,6]
l2 = ['a', 'b', 'c', 'd']
#我们想把两个列表合[(1, 'a'), (2, 'b'), (3, 'c')]这种形式
new_list = []
for i in range(len(l1)):
    new_list.append(l1[i],l2[i])

max和min

l=[1,2,3]
print(max(l))
print(min(l))

 

d = {
    'kevin': 1000,
    'jerry': 30000,
    'Tank': 200000,
    'Oscar': 100
}
print(max(d))#max和min默认情况下返回的是字典的key，也是按照key值比较的,kevin

如果想按d字典中的value的大小来打印出对应的key值

res=max(d,key=lambda x:d[x])

 filter

res = [11, 22, 33, 44, 55, 66]
new_res=[]
for i in res:
    if i>30:
        new_res.append(i)
#匿名函数实现
res1=filter(lambda x : x>30 ,res)

可迭代对象

 迭代，就是更新换代，每一次的更新都是基于上一次的结果

可迭代对象：

        内置有__iter__方法的都可称为可迭代对象

        内置：就是可以直接使用点出来的

注意！开头有_方法也有特殊含义。

str、list、dict、set、tuple、文件类型都是可迭代对象

s=‘helloworld’

res=s.__iter__()

可迭代对象调用__iter__方法之后就是迭代器对象了        

迭代器对象

迭代器：内置有__iter__方法和__next__方法

可迭代对象调用调用__iter__()方法转为迭代器对象

print(res.__next__())

__next__()其实就是迭代取值的，而且不依赖于索引值

s='helloworld'
res=s.__iter__()
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())#d
print(res.__next__())#StopIteration迭代取值被取完，就会报错

 可迭代对象调用多次__iter__方法仍然是迭代器对象
print(res.__iter__().__iter__().__iter__())

易错题
l = [1, 2, 3, 4]
print(l.__iter__().__next__()) # 1
print(l.__iter__().__next__()) # 1
print(l.__iter__().__next__()) # 1
print(l.__iter__().__next__()) # 1
res=l.__iter__()
print(res.__next__())  # 1
print(res.__next__())  # 2
print(res.__next__())  # 3
print(res.__next__())  # 4   

 

for循环内部原理

 如果不用for循环取值

l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
count=0
while True:
    print(l[count])
    count+=1

 for循环的内部原理：

        1.首先把in后面的可迭代对象变为迭代器对象

        2.while循环取值__next__()迭代取值，当next取值完后会报错

        3.当内部报错的时候，for循环进行了异常捕捉

res=l.__iter__()
while True:
    print(res.__next__())
#取值完后会报错

 

异常捕捉

l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
count=0
while True:
    try:
        print(l[count])
        count+=1
    except:
        break

利用异常捕捉就不会出现报错了。

异常就是错误发生的信号，如果不对信号进行处理，那么异常发生位置之后的代码都不能正常执行。

异常的信息：

        1.Traceback：追踪信息，异常发生的位置 

File "D:/Python27/day17/05 for循环内部原理.py", line 21, in <module>

异常发生的位置有时会有很多，直接找最后一行，点击就可以跳转错误发生的位置

        2.xxxError：异常类型

    NameError  KeyError  ...等

        3.错误发生的详细信息（最重要，可以读取错误的原因）

name 'a' is not defined        

异常的分类

1.语法错误

在代码运行时就会出现报错，语法错误，代码一定不会执行，通常可以在语法提示找到错误。

2.逻辑错误

在编码的过程中会允许逻辑错误出现，所以逻辑错误也是最麻烦的

异常如何进行捕捉

try:
    pass
#except NameError as e:
#   print(e)
# except KeyError as e:
#   print(e)
# except IndexError as e:
#   print(e) # list index out of range
# except ZeroDivisionError as e:
#   print(e)
except Exception as e:#Exception是通用类型
    print(e)
else:
    # 当被检测的代码没有异常的时候会走这个语法
    print('这是else语法') # 这是else语法
finally:
    # 不管被监测的代码是否有异常都会走
    print('这是finally语法')