内置函数

all(iteralble) 如果可迭代对象内的所有元素的bool值为真，那么返回真，如果这个可迭代对象是空，也返回真。

all([1,2,3,4])  # return True
all([])         # return True
all([None, 1, 'a']) # return False

any(iterable) 和 all(iteralble) 类似，只是只要有一个元素为真，那么就是真
bytes(obj) 将一个对象转为字节

bytes('abc',encoding='utf-8')   # b'abc'
bb = bytes([1,2,3,4])   # b'\x01\x02\x03\x04'

callable(obj) 对象是否可调用，返回True/False 注意，所有的类都是可调用的，因为类的实例都有一个__call__() 方法
chr(i) 数字转字符；ord(c) 字符转编码
dir(obj) 查看对象的所有属性/方法
help(obj) 查看帮助文档
divmod(x, y) return the tuple (x//y, x%y) 商和余。例如，计算网页需要分多少页显示：

def count(x, y):
    res = divmod(x, y)
    if res[1] > 0:
        return res[0]+1
    return res[0]
# 假设有200条评论，每页显示50，需要多少页
print(count(200, 50)) # 结果 5

enumerate(iterable obj) 迭代取值，返回元组（索引，元素）组成的新的可迭代对象（可以用for i in 或 list 来取值）。如果对象类型是dict，元组形式就是（索引，key）

list(enumerate(['a','b','c']))  # [(0, 'a'), (1, 'b'), (2, 'c')]
list(enumerate({'name': 'Seb', 'age': 22, 'sex': 'male'}))   # [(0, 'name'), (1, 'age'), (2, 'sex')]

frozenset() 创建一个不可变的集合
isinstance(obj, class) 判断对象的类型，返回True/False
pow(x, y, z) 对x进行y的幂运算然后除z取余：x**y%z
reversed() 反转，返回一个可迭代对象list(reversed('abc')) # ['c', 'b', 'a']
round(float, 保留的小数位） round(9.2356, 3) # 9.236
slice(x, y, z) 创建一个切片对象

x = slice(0,5,2)    # 创建一个切片对象x
l = [1,2,3,4,5,6]
print(l[x])     # [1, 3, 5]

sorted(iterable, reverse=False) 排序返回一个列表

print(sorted('baefc')) # ['a', 'b', 'c', 'e', 'f']
print(sorted('baefc', reverse=True))    # ['f', 'e', 'c', 'b', 'a']

zip(序列1, 序列2) 拉链函数，返回一个zip obj（迭代器，可通过list或for i in 取值），左边序列的的元素对应右边序列的唯一元素，结合为元组。

s = 'abcde'
l = [1,2,3,4,5,6,]
print(list(zip(s, l)))  # [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]

匿名函数lambda

基本形式：

lambda: args : expression ，表达式的结果就是函数的return value

func = lambda x:x*2
func(2)     # 也可以这样来调用
lambda x : x < 3 # 返回True/False

why lambda?

定义一个有名函数时def func():pass，只要名字不被删除，就一直占着内存。如果只用一次，用完了还要del func。但是lambda匿名函数，只是一个内存地址，没有绑定变量名，会被回收。另外，简单的函数用lambda写更方便。

lambda和内置函数map, reduce, filter,max的应用

map 映射：map(函数, 序列)

map迭代序列，将元素传给函数，将函数返回的结果组成map obj这个迭代器，可以用list或for循环来查看。

m = map(lambda x : x*2, [1, 2, 3, 4])
print(list(m))  # [2, 4, 6, 8]

reduce 合并：reduce(函数，序列，初始值）

在python3中使用reduce函数需要 from functools import reduce 导入。

from functools import reduce
print(reduce(lambda x,y :  x+y, range(100))) # reduce循环序列的元素，让函数每次接收两个元素，
# 返回的结果再和序列的下一个元素作累积计算

filter 过滤：filter(函数，序列）

循环序列的元素，让函数判定元素的bool值，如果为真，返回元素组成的filter obj 迭代器对象。

print(list(filter(lambda x : x > 0, [-3, -5, 2, 1])))   # [2, 1]

max

用max函数找出一个字典中的最大值。

# 找出分数最高的那位同学
d = {'Ayhan': 100, 'Seb': 98, 'Tom': 97, 'Ronin': 98}
res = zip(d.values(), d.keys()) # max() 遵循迭代器协议，如果传入的字典，那么比较key的大小。所以用zip处理一下。
print(max(res))  # (100, 'Ayhan')

max(dict, key=func) max函数中的key可以指定比较的对象。循环字典得到key，把字典key传给key的函数处理后得到的返回值，再作比较。注意，max的key和字典的key不同。上面的栗子可以改写：

d = {'Ayhan': 100, 'Seb': 98, 'Tom': 97, 'Ronin': 98}
print(max(d, key = lambda x : d[x]))    # Ayhan

迭代器协议

很多内置函数都是遵循迭代器协议的，上面的函数：filter()、map()、reduce()、max()、min()、list()、for i in iterable。遵循迭代器协议的函数能对可迭代对象就行迭代。

秒客网

内置函数与lambda匿名函数