内置函数汇总及匿名函数
内置函数汇总及匿名函数
匿名函数及其应用
匿名函数指没有函数名的函数，无法通过名字找到它的代码，他可以代替如下的结构：
def func(a, b):
return a+b
# 只传参和只返回，所有的表达式在return后写完的结构
匿名函数关键字lambda
lambda 形参:返回值 # lambda语法
代替上述代码写为：
lambda a, b: a+b
匿名函数的应用场景很小，因为代码不能被函数名找到，所以即用即丢。
它常常搭配一些需要传入函数实参的内置函数使用。
内置函数汇总
| map | max\min | reduce |
|---|---|---|
| zip | filter | sorted |
| abs | all\any | divmod |
| bin\oct\hex | hash | bytes |
| callable | pow | eval\exec |
| isinstance | enumerate | pow |
| dir | chr\ord | round |
重要内置函数
map() —— 映射
map(函数, 可遍历对象) 指将遍历的元素挨个取出来做函数的形参，得到的返回值放到map工厂里，map工厂转换为列表的结果就是每个被函数处理好的元素组成的列表
l1 = [1, 2, 3, 4, 5]
'''如果用有名函数
def func(a):
return a + 1
res = map(func, l1)
'''
res = map(lambda x:x+1, l1) # 而匿名函数这种简单又临时的函数很适合用在这里
print(list(res)) # [2, 3, 4, 5, 6]
"""
元素1经过匿名函数变成2,
元素2经过匿名函数返回3
以此类推
最终res会接收一个迭代器，可以被for循环，所以可以被list()转换为列表
"""
max()/min() —— 最大最小值
# 简单的比较
l1 = [11, 22, 33, 44]
res = max(l1) # 44
# 依据映射关系比较
d1 = {
'leethon': 100,
'jason': 8888,
'lalisa': 99999999,
'alex': 1000
}
# def func(a): # 传键
# return d1.get(a) # 返回字典的值
# res = max(d1, key=func) # key后面跟函数
res = max(d1, key=lambda k: d1.get(k)) # 根据键的值来比较
print(res) # lalisa # 但是返回的是键
max根据映射关系比较的逻辑是：
根据遍历元素映射后的值作依据比较，得到的结果是映射前原本的元素。
reduce()
# reduce 传多个值，返回一个值
from functools import reduce # 已经不是内置方法了，需要导入模块
l1 = [1, 2, 3, 4, 5]
res = reduce(lambda a, b: a + b, l1) # 计算 ((((1+2)+3)+4)+5)
print(res)
zip —— 拉链
缝合多个列表的数据，将对应位置的元素组成一个小元组放到列表中。
l1 = [1, 2, 3, 4, 5]
l2 = ['a', 'b', 'c', 'd']
l3 = [11, 22, 33, 44, 55, 66]
res = zip(l1, l2, l3)
print(res) # <zip object at 0x00000222BA9E7280> 迭代器对象
print(list(res)) # [(1, 'a', 11), (2, 'b', 22), (3, 'c', 33), (4, 'd', 44)]
# 每个对应位置的值被组合为元组，对应不上就不组合。
filter —— 过滤
根据判断依据，过滤掉迭代对象中的一些值。
结构：filter(函数, 迭代器对象)
如：
l1 = [11, 22, 33, 44, 55, 66, 77, 88]
res = filter(lambda x: x > 40, l1)
print(list(res)) # [44, 55, 66, 77, 88]
# 只拿>40的值
sorted —— 排序
默认升序，给列表排序
l1 = [13, 12, 533, 64, 766, 322, 131, 22]
res = sorted(l1)
print(res) # [12, 13, 22, 64, 131, 322, 533, 766]
这个功能和列表内置方法的l.sorted实际一样。
常见内置函数
abs —— 绝对值
abs(-1) # 1
# |-1|
abs(10) # 10
all —— 全与
all内传入迭代值，判断所有值对应都是True，则返回True
all([1, 2, 3, 4]) # True
all([0, 1, 2, 3, 4]) # False
类似于：
0 and 1 and 2 and 3 and 4
# 节省代码好能手
any —— 全或
any([0, 1, 2, 3, 4]) # True
类似于：
0 or 1 or 2 or 3 or 4
bytes —— 转换为bytes类型数据
s1 = '最近缺觉'
print(bytes(s1, encoding='utf8'))
print(s1.encode('utf8'))
callable —— 可执行判断
函数是可执行的，一般的数据是不可执行的
name = 'leethon'
callable(name) # False
def index():
pass
callable(index) # True
# 无论是函数还是变量，都是名字形式的，就可以用此函数来判断。
chr\ord —— ASCII码值的数字字母对应转换
65-90 是A-Z，97-122 是a-z。
print(chr(90)) # z
print(ord('Z')) # 122
dir —— 查看对象内置方法
dir()内传入的所有名字可以看做对象，这些对象有一些能够通过点.的方式调用的内置方法，可以使用dir来查看。
name = 'leethon'
print(dir(name))
# 在输出的列表中，有很多我们之前学过的内置方法
divmod —— 整除和取余
divmod(100, 3) # (33, 1)
# 应用实例
已知：数据量要分页，数据量为99，分页要求一页显示10条数据
总数据 每页展示的数据 总页码
100 10 10
99 10 10
101 10 11
page_num, more = divmod(99, 10)
if more: # 如果余数不为0，需要多一页数据来显示数据
page_num += 1
enumerate —— 枚举
通过遍历迭代器对象，得到一个序号与值的二元组迭代器。
list(enumerate([1, 2, 3, 4, 5])) # [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]
# start参数，改变序号的开头
# 例子：ASCII表大写字母打印
l1 = [chr(i) for i in range(65, 91)]
print(list(enumerate(l1, start=65)))
[(65, 'A'), (66, 'B'), (67, 'C'), ……, (90, 'Z')]
hash —— 哈希加密
print(hash('leethon')) # 3260713259912227457
print(hash('123')) # -6488149301417385444
将内容加密，在你的机器上按hash同样加密得到的是同一段密文。
isinstance —— 判断数据类型
isinstance(111, int) # True
isinstance([111,] , int) # False
eval/exec() —— 执行字符串映射的python代码
eval('python代码字符版')
exec('代码字符版'，{}，变量)
# 执行结果，执行代码，产生属性放到字典里，存到变量中。
# 这个变量存的就是这个代码的名称空间（字典类型）
pow —— 幂指数
print(pow(3, 2)) # 9
print(pow(3, 3)) # 27
print(pow(3, 4)) # 81
等同于 3**2\3**3\3**4
round —— 四舍五入取整
print(round(98.3)) # 98
print(round(98.51)) # 99
sum —— 求和
print(sum([11, 22, 33, 44, 55, 66])) # 231
