计算机基础知识17

匿名函数

匿名函数：其实就是没有名字的函数   # 也需加括号

                  里面不能写for循环/while循环/比较大小等等，只能写简单的

语法格式：lambda  形参:返回值    #  res = lambda x:x**2

def index(x):
   return x**2
index(2)

res = lambda x,y:x+y
print(res)     # 匿名函数的内存地址
print(res(1, 2))    # 3

常见的内置函数

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

# 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)
print(list(res))    # [1, 4, 9, 16, 25, 36, 49]

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

res = zip(l1, l2) 
print(list(res)) # [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]
"""如果长度不一，按短的来"""

# max    比较大小

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

如若比较value值，返回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)     # Tank Oscar

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)

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

可迭代对象

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

               比如游戏更新有全量更新和增量更新（很难实现）

# 可迭代对象：内置有__iter__方法的都可以称之为是可迭代对象

# '内置': 直接可以使用点出来的

i = 123              # X
f = 1.1              # X
s = 'hello'          # s.__iter__()
l = [1, 2, 3, 4]     # l.__iter__()
t = (1, 2, 3, 4)     # t.__iter__()      是可迭代对象
se = {1, 2, 3, 4}    # se.__iter__()
d = {'a':1, 'b':2}   # d.__iter__()
b = True             # X
file = open('a.txt', 'w')    # file.__iter__()

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

res = s.__iter__()   # res就是迭代器对象
'''可迭代对象调用__iter__方法之后就是迭代器对象了'''
print(s.__iter__())  # 
print(iter(s))
'''简写：方法名() #iter()'''

# 可迭代对象调用多次__iter__方法仍然是迭代器对象:

         print(res.__iter__().__iter__().__iter__())

迭代器对象

# 迭代器：内置有__iter__方法还内置有__next__方法

# 如何转为迭代器对象:  有可迭代对象调用__iter__()方法转为迭代器对象

s = 'hello'
res=s.__iter__() # 迭代器对象
print(res.__next__())    # h
print(res.__next__())    # e
print(res.__next__())    # l
print(res.__next__())    # l
print(res.__next__())    # o  取值完会报错
"""next其实就是迭代取值的，而且不依赖于索引取值"""

简写：print(res.__next__()) >>>  print( next(res) )

#### 易错题:

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
"""每次调用iter都是新的迭代器再next取值"""

res = l.__iter__()
print(res.__next__())  # 1
print(res.__next__())  # 2
print(res.__next__())  # 3
print(res.__next__())  # 4   
"""是同一个迭代器里取值，可以依次取出，不依赖索引"""

for循环内部原理

l = [1, 2, 3, 4, 5, 6, 7, 8, 9]  # 循环打印出列表中每一个元素值，但是不能使用for循环
# 普通函数取值
count=0
while True:
    print(l[count])
    count+=1    # 取完会报错

# 迭代器取值
l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
res=l.__iter__()
while True:
    print(res.__next__())    # 取完也会报错

# for循环内部的原理：    # while循环+迭代器取值+异常捕捉

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

for i in l:
    print(i)

res=l.__iter__()
while True:
    try:          # 异常捕捉，在快报错的时候
        print(res.__next__())
    except:
        break

异常捕捉

1、异常：错误发生的信号，如果不对该信号做处理，异常发生位置后的代码都不能正常运行

2、异常的信息：
Traceback：追踪信息，异常发生的位置
      File "D:/Python27/day17/05 for循环内部原理.py", line 21, in
      有时候错误发生的信息会有很多行，找最后一行，然后点击可以跳转

XXXError: 异常发生的类型
    NameError  KeyError  ...
错误发生的详细信息(最重要的：一般情况从这里就可以知道错位发生的原因)
      name 'a' is not defined

3、异常的分类：语法错误：是不允许的，语法错误，代码是不能够运行，可以通过代码                                                      提示知道语法错误原因
                         逻辑错误：在编码过程中，逻辑错误是允许出现的，尽量避免

4、异常捕捉：NameError  变量名错误        print(a)   没加" "

                        KeyError     取key值错误       l [g]  不存在

          ZeroDivisionEorror   0除法错误           1/0

                       lndexError    索引错误            [5]  不存在

5、代码的健壮性：尽量少报错

try:
    被检测的代码
except '异常类型' as e:
    print(e)   # 打印错误信息   

只能当你的被监测代码可能会出现，不想让它报错，这时可使用异常捕捉，尽量少的写

try:                 #异常捕捉，不会报错
    l = [1, 2, 3]
    print(l[5])      # IndexError  错误
except NameError as e:       
    print(e)               # 打印出错误的，如[5]
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)
print(123)       # [5]   123 ,异常捕捉后，下面代码还是会运行，并且打印出错误的地方

6、else和finally：

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

注意：try和else不能单独使用！

今日思维导图：