Python从入门到放弃之匿名函数，for循环原理，异常捕捉

匿名函数

匿名函数：其实就是没有名字的函数
        # 匿名函数也是必须加括号才能使用

语法格式：
    lambda 形参:返回值
     def index(形参)：
         返回值

 res = lambda x:x**2
 
方法一
 def index(x):
     return x**2
 index(2)
 
方法二
 
res = lambda x,y:x+y
print(res(1, 2))

配合匿名函数一起使用的内置函数

map zip max min filter...

# map
ll = [1, 2, 3, 4, 5, 6, 7]
def index(x):
    return x ** 2
res = map(lambda x: x ** 2, ll)  # 
print(list(res)) 

# zip 拉链
l1 = [1, 2, 3,4,5,6]
l2 = ['a', 'b', 'c', 'd']
l3 = ['kevin', 'jerry', 'tank', 'oscar']
l4 = ['kevin1', 'jerry2', 'tank3', 'oscar4']

res = zip(l1, l2, l3, l4)
print(list(res)) 

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

def index(x):
    return d[x]


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

##filter的使用
res = [11, 22, 33, 44, 55, 66]

def index(x):
    return x>30
res1=filter(lambda x:x>30, res) # 内部也是for循环
print(list(res1))

可迭代对象

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

可迭代对象：
    内置有__iter__方法的都可以称之为是可迭代对象
    '内置': 直接可以使用点出来的
 

s.__iter__()
l.__iter__()
t.__iter__()
se.__iter__()
d.__iter__()
file = open('a.txt', 'w')
file.__iter__()

可迭代对象：
    str、list、dict、set、tuple、文件类型
以上基本数据类型都是可迭代对象

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

print(s.__iter__()) # <str_iterator object at 0x0000023F68F31100>
print(iter(s))
 
def iter(s):
    return s.__iter__()
 
print(len(s))
print(s.__len__())
 
def len(s):
    return s.__len__()

__iter__开头的方法都有一个与之对应的简写：iter(s) 方法名()

迭代器对象

迭代器：
    内置有__iter__方法还内置有__next__方法
    
如何转为迭代器对象
    有可迭代对象调用__iter__()方法转为迭代器对象
    

# 可迭代对象调用多次__iter__方法仍然是迭代器对象
# print(res.__iter__().__iter__().__iter__())
 
#### 易错题
l = [1, 2, 3]
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

迭代器给我们提供了一种不依赖于索引取值的方式
# 可迭代对象调用多次__iter__方法仍然是迭代器对象
 

for循环内部原理

l = [1, 2, 3, 4, 5, 6, 7, 8] # 循环打印出列表中每一个元素值，但是不能使用for循环


res=l.__iter__()
while True:
    try:
        print(res.__next__())
    except:
        break

    for循环内部的原理：
        1. 首先把关键字in后面的可迭代对象转为迭代器对象
        2. while循环取值__next__迭代取值，当next取值完毕的时候会报错
        3. 当内部报错的时候，for循环进行了异常捕捉
 

异常捕获

什么是异常：
    异常就是错误发生的信号，如果不对该信号做处理，那么，异常发生的位置之后的代码都不能正常运行
    
异常的信息：
    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. 逻辑错误
        # 在编码过程中，逻辑错误是允许出现的
        但是我们应该尽量避免逻辑错误出现的可能性
        l = [1, 2, 3]
        if i < len(l):
            print(l[i])

异常如何进行捕捉
try:
    l = [1, 2, 3]
    print(l[4])
   
except Exception as e:
    print(e)
else:
    # 当被检测的代码没有异常的时候会走这个语法
    print('这是else语法') # 这是else语法
finally:
    # 不管被监测的代码是否有异常都会走
    print('这是finally语法')
print(123)


l = [1,2,3,4,5,6,7]
res= l.__iter__()
while True:
    try:
        print(res.__next__())
    except Exception:
        break

当被监测代码可能会出现，但又不想让它报错，这个时候使用异常捕捉是最合适的
异常捕捉的代码尽量少的写