学习Python的第13天

1.匿名函数

1.1匿名函数的定义：

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

格式：

lambda 形参：返回值

2.常见的内置函数

map zip max min filter等通常与匿名函数来配合使用。

# map
ll = [1, 2, 3, 4, 5, 6, 7]


# new_res = []
# for i in res:
#     new_res.append(i ** 2)
#
# print(new_res)

def index(x):
    return x ** 2


# res=map(index, ll) #
res = map(lambda x: x ** 2, ll)  # 
print(list(res))  # [1, 4, 9, 16, 25, 36, 49]

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

# [(1, 'a'), (2, 'b'), (3, 'c')]
# new_list = []
# for i in range(len(l1)):
#     new_list.append((l1[i], l2[i]))
#
# print(new_list) # [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f')]

res = zip(l1, l2, l3, l4) # [(1, 'a', 'kevin'), (2, 'b', 'jerry'), (3, 'c', 'tank')]
print(list(res)) # [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

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


# print(max(d))
# print(min(d))

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]
# new_res = []
# for i in res:
#     if i > 30:
#         new_res.append(i)
# print(new_res)


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

3.可迭代对象

3.1定义

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

3.2可迭代对象

内置有_iter_方法的都称之为是可迭代对象。

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

且可迭代的对象为：tuple ,str,list,dict,set,文件类型

​'''可迭代对象调用__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) 方法名()
"""
​

4.迭代器对象

4.1定义

内置有_list_方法还有内置有_next_方法

4.2如何转为迭代器对象

有可迭代的对象调用_iter_()方法转为迭代器对象

# res=s.__iter__() # 迭代器对象
# print(res.__next__())  # next其实就是迭代取值的，而且不依赖于索引取值
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())
#
# res1 = l.__iter__()
# print(res1.__next__())
# print(res1.__next__())
# print(res1.__next__())
# print(res1.__next__())
# print(res1.__next__())  # 迭代取值，一旦值被取完，就会直接报错

# print(next(res1))
# print(next(res1))
# print(next(res1))
# print(next(res1))

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

5.for循环内部原理

1.首先把关键字in后面的可迭代对象转为迭代器对象

2.while循环取值_next_迭代取值，当next取值完毕的时候会报错

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

6.异常捕捉

6.1定义

什么是异常：异常就是这段代码有问题，如果不处理就会影响后面代码的运行。

6.2异常的信息

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

2.XXXError：异常发生的类型

3.错误发生的详细信息

6.3异常的分类

语法类：是代码运行过程中一开始就不允许的，只要语法错误，代码一定是不能够运行的

通过代码提示就知道语法错误在哪

逻辑性：在编码过程中逻辑性的错误是被允许的但是我们应该避免逻辑性出现的可能性

6.4异常如何捕捉

try:
    l = [1, 2, 3]
    print(l[4]) # IndexError
    # d = {'a':1}
    # print(d['b'])
    # 1/0
# 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:
    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