匿名函数
语法是：`lambda 参数 ：返回值`
匿名函数没有名字，只能和某些方法联用
1.max
返回最大值
res = max([1,2,3,4,5])
print（res） # 5
salary_dict = {
'nick': 3000,
'jason': 100000,
'tank': 5000,
'sean': 2000,
'z': 1000
}
def func(name): # nick/jason/tank/sean/z
return salary_dict[name] # 3000/100000/5000/2000/1000
res = max(salary_dict, key=func) # 默认key的首字母
# jason
print(res)
字典按照值来排序取值 ，key=func默认做的事：
- 循环遍历 salary_dict字典中的所有key 值
- 然后把所有的key值一次丢入func中，返回薪资
- 通过返回的薪资排序，得到最大值
利用max与匿名函数联用可以写成：
def func(name):
return salary_dict[name]
res = max(salary_dict, key=lambda name: salary_dict[name]) # 默认key的首字母
print(res)
2.min
取最小值
res = min(salary_dict, key=lambda name: salary_dict[name])
print(res)
3.filter
通过函数控制筛选可迭代对象内元素的输出。
res = filter(lambda item: item > 2, [1, 2, 3, 4])
print(res) # <filter object at 0x000002656CDE68D0>
print(list(res)) # [3, 4] 强转为列表输出
res = filter(lambda item: salary_dict[item] > 3000, salary_dict)
print(list(res)) # ['jason', 'tank']
# 筛选出了大于3000薪资的人
4.map
映射(y=x+1)。会以特定条件让可迭代对象一一映射执行。
def function1(item):
return item + 2
res = map(function1, [1, 2, 3, ])
print(res)
print(list(res))
# [3, 4, 5]
5.sorted
对可迭代对象进行排序。
res = sorted([2,3,4,1,0,5],reverse=True)
key= 函数。在字典中以值进行排序可以使用
salary_dict = {
'nick': 3000,
'jason': 100000,
'tank': 5000,
'sean': 2000,
'z': 1000
}
def function2(item):
return salary_dict[item]
res = sorted(salary_dict, key=function2, reverse=True)
print(list(res))
内置函数
python解释器内置方法
enumerate（***）
可以循环打印出可迭代对象的索引和值。
lt = [1, 2, 3]
for ind, val in enumerate(lt):
print(ind, val)
eval (*)
可以把字符串的引号去掉，留下的是什么就是什么
s = '"abc"'
print(type(eval(s)), eval(s))
# <class 'str'> abc
s = '[1,2,3]'
.print(type(eval(s)), eval(s))
# <class 'list'> [1, 2, 3]
bytes
解码字符，将字符串变为二进制流
res = bytes('中国', encoding='utf8')
print(res)
# b'xe4xbdxa0xe5xa5xbd'
chr() / ord()
chr()参考ASCII码表将数字转成对应字符；ord()将字符转换成对应的数字。
print(chr(65)) # A
print(ord('A')) # 65
divmod()
得到两个数（取整/取余）
print(divmod(10, 3)) # (3, 1)
print(divmod(10, 4)) # (2, 2)
hash()
是否可哈希(可变类型不可哈希)
print(hash(123)) # 123
以下了解
1.abs()
求绝对值。
print(abs(-13)) # 求绝对值
13
2.all()
可迭代对象内元素全为真，则返回真。
print(all([1, 2, 3, 0]))
print(all([]))
False
True
3.any()
可迭代对象中有一元素为真，则为真。
print(any([1, 2, 3, 0]))
print(any([]))
True
False
4.bin() / oct() / hex()
二进制、八进制、十六进制转换。
print(bin(17)) # 0b10001
print(oct(17)) # 0o21
print(hex(17)) # 0x11
5.dir()
列出模块的所有方法（以下是time模块的）
import time
print(dir(time))
['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'clock', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'perf_counter', 'process_time', 'sleep', 'strftime', 'strptime', 'struct_time', 'time', 'timezone', 'tzname', 'tzset']
6.frozenset()
不可变集合。
s = frozenset({1, 2, 3})
print(s)
frozenset({1, 2, 3})
# 这个集合是不可变的
7.globals()/loacals()
查看全局名字；查看局部名字。
# print(globals())
def func():
a = 1
# print(globals())
print(locals())
func()
{'a': 1}
8.pow()
次方求值
print(pow(3, 2, 3)) # (3**2)%3
0
9.round()
四舍五入
print(round(3.5))
4
10.slice()
python2 遗留的切片方式
lis = ['a', 'b', 'c']
s = slice(1, 4, 1)
print(lis[s]) # print(lis[1:4:1])
['b', 'c']
11.sum()
求和
print(sum(range(100)))
# 4950
print(sum([1,2,3,4,5]))
# 15
12.import()
通过字符串导入模块。
m = __import__('time')
print(m.time())
1556607502.334777
异常处理
报错之后还能继续执行
try:
代码块（将要出错的）
except exception：
# 可以拦截所有错误
- 报错之后，虽被拦截，但是之后的代码不会执行
Exception是万能异常，只要有错误就会捕捉- 异常捕捉只能捕捉逻辑错误，语法错误由python解释器自己拦截
except exception as e：可以将错误作为变量e打印出来finally判断，无论报错与否，都执行这一行assert断言 + 条件：被历史淘汰，判断词句是否出错（cmd编辑时用）
面向过程编程
IP0
input 输入（定义的变量）
process 过程（控制变量的改变）
output 输出（新的变量）
面向对象的编程更像是流水线，一步一步的走下去
优点：逻辑清晰
缺点：上一步错了，下一步就跟着一起错
为什么会报错
逻辑 ==》 控制变量改变的方向出错
检查错误==》 不断打印变量的拜年话==》寻错