函数与迭代器对象拓展知识

函数与迭代器对象拓展知识

  · 结合匿名函数一起使用的函数

  · 可迭代对象

  · 迭代器对象

  · for循环内部本质

  · 生成器

  · 常见内置函数

  一、常见内置函数

  1.map()    映射

  循环获取列表中每个元素并传递给匿名函数保存返回值

l = [1,2,3,4]
map(lambda x:x+1,l)

  2.zip()    拉链

  可将两个数组进行结合，取值取最短的数组，合并数组以字典或列表表示

l = [11, 22, 33, 44, 55, 66, 77]
name_list = ['jason', 'kevin', 'tony', 'jerry']
l1 = [1, 2, 3, 4, 5, 6, 7]
l2 = [8, 7, 6, 4, 3, 2, 1]
# new_list = []
# for i in range(len(l)):
#     new_list.append((l[i],name_list[i]))
# print(new_list)
res = zip(l, name_list, l1, l2)
print(list(res))

  3.max与min

  max求最大值  min求最小值

# l = [11, 22, 33, 44, 55, 66, 77]
# print(max(l))
# print(min(l))

d = {
'jason':3000,
'Bevin':1000000,
'Ascar':10000000000,
'aerry':88888
}
# def index(key):
# return d[key]
# print(max(d,key=lambda key:d[key])) # for循环先取值 之后再比较大小
"""
A-Z 65-90
a-z 97-122
"""
# print(min(d,key=lambda key:d[key])) # jason

  4.filter  过滤

  把列表的中想删除的数值进行过滤删除

l = [11, 22, 33, 44, 55]
res = filter(lambda x: x > 30, l)
print(list(res))  # [33, 44, 55]

  5.reduce  归总

  将一个数组的元素值进行总和，还可以额外添加元素值

from functools import reduce
d = [11, 22, 33, 44, 55, 66, 77, 88, 99]
res = reduce(lambda x, y: x + y, d)
res1 = reduce(lambda x, y: x + y, d, 100)  # 还可以额外添加元素值
print(res)

  二、可迭代对象

  迭代：迭代及更新换代  每次的更新都必须依赖于上一次的结果

  迭代其实给我们提供了一种不依赖索引取值的方式

  可迭代对象

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

    内置的意思是可以通过点的方式直接查看到的

  针对双下划线开头  双下划綫结尾的方法  最为专业标准的读法为双下方法名

  面向对象的时候为了与隐藏变量区分开

# n = 1
# while True:
#     n+=1
#     print(n)

# l = [11,22,33,44,55,66]
# n = 0
# while n < len(l):
#     print(l[n])
#     n += 1

i = 12  # 没有
f = 11.11  # 没有
s = 'jason'  # 有
l = [111,22,33,4]  # 有
d = {'username':'jason','pwd':123}  # 有
t = (11,22,33)  # 有
se = {11,22,33}  # 有
b = True  # 没有
# file = open(r'a.txt','w',encoding='utf8')

  含有_iter_的有

    字符串 列表 字典 元组 集合 文件对象

  上述通常为可迭代对象

print(d)
print(d.__iter__())  # 等价于调用了一个内置方法 d.get()
print(iter(d))
print(d.__len__())
print(len(d))

  可迭代对象调用_iter_方法会变成迭代器对象

  _iter_方法在调用的时候还有一个简便的写法iter()

    一般情况下所有的双下方法都会有一个与之对应的简化版本  方法名()

  三、迭代器对象

迭代器对象

    即含有_iter_方法 又含有_next_方法

  如何生成迭代器对象

    让可迭代器对象执行_iter_方法

  文件对象本身既是对象优势迭代器对象

  迭代器对象无论执行多少次_iter_方法  还是迭代器对象

  迭代器给我们提供了不依赖于索引取值的方式

i = 12  # 没有
f = 11.11  # 没有
s = 'jason'  # 有
l = [111,222,333,444]  # 有
d = {'username':'jason','pwd':123}  # 有
t = (11,22,33)  # 有
se = {11,22,33}  # 有
b = True  # 没有
file = open(r'a.txt','w',encoding='utf8')

# res = s.__iter__()  # 转成迭代器对象
# print(res.__next__())  # 迭代器对象执行__next__方法其实就是在迭代取值(for循环)
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())


# res = d.__iter__()  # 转成迭代器对象
# print(res.__next__())  # 迭代器对象执行__next__方法其实就是在迭代取值(for循环)
# print(res.__next__())
# print(res.__next__())  # 取完元素之后再取会"报错"

# 易错
# print(d.__iter__().__next__())  # username
# print(d.__iter__().__next__())  # username
# print(d.__iter__().__next__())  # username
# print(d.__iter__().__next__())  # username
# print(d.__iter__().__next__())  # username
# print(d.__iter__().__next__())  # username

  四、for循环的本质

  for循环内部原理

  1.将关键字in后面的数据先调用_iter_方法转为迭代器对象

  2.循环执行_next_方法

  3.取完之后_next_会报错 但是for循环会自动捕获该错误并处理

res = 数据.__iter__()
while True:
    检测代码是否会报错
    res.__next__()
    如果报错了则自动处理掉并结束while循环

  五、异常捕获

  1.什么是异常

    代码运行出错会导致异常  异常发生后如果没有解决方案则会整个程序结束

  2.异常三个重要组成部分

  1>traceback

    翻到最下面从下往上的第一个蓝色字体鼠标左键点击即可跳转到错误的代码所在行

  2>xxxError

    错误的种类

  3.错误类型冒号后面的内容

    错误的详细原因

  3.错误的种类

    1.语法错误

        不被允许的 出现了之后尽快修改即可

        修改逻辑错误的过程其实就是在从头到尾理清思路的过程

# print(idna)  # NameError
# l = [11,22,33]
# print(l[100])  # IndexError
# d = {'username':'jason'}
# print(d['xxx'])  # KeyError
# int('abc')  # ValueError

  基本语法结构

# try:
#     int('abc')
# except NameError as e:
#     print('变量名name不存在',e)
# except ValueError:
#     print('值不是纯数字')

  万能异常

try:
    # int('abc')
    print(name)
    # l = [11]
    # l[100]
except Exception:
    print('你来啥都行 无所谓')

  异常捕获句式和万能异常

        1.有可能会出现错误的代码才需要被检测

　　  2.被检测的代码一定要越少越好

　　  3.异常捕获使用频率越低越好