匿名函数、内置函数、异常处理、面向过程编程

一、匿名函数

函数没有名字，没有方法调用，只能和某些方法连用（max,min,filter,map,sorted）

匿名函数的语法： lambda 参数：返回值  例如：lambda x,y :x*y

1.max 返回最大值  max(初始数据,key=从初始数据的哪个角度来选最大值)

salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000
}
res = max(salary_dict,key=lambda x:salary_dict[x])
print(res)
打印结果为：'jason'

2.min返回最小值  min(初始数据，key=从初始数据哪个角度来选最大值)

salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000
}
res = min(salary_dict,key=lambda x:salary_dict[x])
print(res)
打印结果为：'sean'

3.filter筛选出结果  filter(筛选的条件，初始数据)

salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000
}
res = filter(lambdax:salary_dict[x]>3000,salary_dict)
print(list(res))
打印结果为：['jason', 'tank']

4.map 映射 y=x+1

res = map(lambdax:x+1,[1,2,3,4])
print(list(res))
打印结果为：[2, 3, 4, 5]

5.sorted 排序 sorted(初始数据，key=排序角度条件，reverse = True) reverse控制的是升序或降序

salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000
}
res = sorted(salary_dict,key=lambda x:salary_dict[x],reverse=True)
print(list(res))
打印结果为：['jason', 'tank', 'nick', 'sean']

res = sorted([1,23,1,2,2,23,32],reverse=True)
print(list(res))
打印结果为：[32, 23, 23, 2, 2, 1, 1]

 二、内置函数

1.bytes()  解码字符

2.chr()/ord()

chr()参考ASCII码表将数字转成对应字符

ord()将字符转换成对应的数字。

3. divmod() 取整取余，元祖的格式打印出来

4. enumerate() 索引加取值

lt = [1, 2, 3] 
for ind, val in enumerate(lt): 
　　print(ind, val)
打印结果为：0 1
          1 2
          2 3

5.eval() 把字符串的引号去掉，留下什么就是什么，如果是字符串，则变成变量名，如果找不到对应的变量值，就报错

s = '"abc"' 
print(type(eval(s)), eval(s))
打印结果为：<class 'str'> abc

6.hash()

了解

1.abs() 取绝对值

2.all() 可迭代对象内元素全为真，则返回真

3.any() 可迭代对象中有一元素为真，则为真

4.bin()/oct()/hex()  二进制、八进制、十六进制转换

5.dir() 列举出所有time的功能

6.frozenset() 不可变集合,类似元祖

7.globals()/loacals() 查看全局名字；查看局部名字。

8.pow()  幂运算

9.round() 四舍五入

10.slice() 切片取值

11.sum() 求和

12.__import__() 通过字符串导入模块 需要赋值

 三、异常处理

报错后不执行下面的代码

 异常只捕捉逻辑错误

tyr:
    
except Exception as e:
    print(e)

raise 主动抛出错误

raise('出错了')

四、面向过程编程 

类似于生产线，一步一步往下走

优点：逻辑非常清晰

缺点：上一步出错，下一步跟着一起错