python官方文档内置函数BIF：https://docs.python.org/3/library/functions.html
数学相关：
abs(a) : 求取绝对值。abs(-1)
max(list) : 求取list最大值。max([1,2,3])
#1.传入的多个参数的最大值
print(max(1,2,3,4)) #输出 4
#2.传入可迭代对象时，取其元素最大值
s=‘12345‘
print(max(s)) #输出 5
#3.传入命名参数key，其为一个函数，用来指定取最大值的方法
s = [
{‘name‘: ‘sumcet‘, ‘age‘: 18},
{‘name‘: ‘bbu‘, ‘age‘: 11}
]
a = max(s, key=lambda x: x[‘age‘])
print(a) #输出 {‘name‘: ‘sumcet‘, ‘age‘: 18}
min(list) : 求取list最小值，同sum()。
sum(list) : 求取list元素的和。
1. 函数功能是对可迭代类型进行求和。要求：① 接收对象是可迭代类型。② 可迭代对象所有元素类型是数值型。
sum([1,2,3]) ，sum((1,2,3))。
2. 可以传入一个可选参数start，表示求和前的初始化值，如果传入空的可迭代数据类型，则返回初始值。
>>> sum((1,2,3,4),2) 12 # 传入空可迭代对象，直接返回初始值 >>> sum([],2) 2
sorted(list) : 排序，返回排序后的list。
sorted([36,6,-12,9,-22],key=abs) 高阶函数，以绝对值大小排序
如果需要排序的是一个元组，则需要使用参数key，也就是关键字。
>>> a = [(‘b‘,2), (‘a‘,1), (‘c‘,0)] >>> list(sorted(a,key=lambda x:x[1])) 按照元组第二个元素排序
sorted([‘bob‘, ‘about‘, ‘Zoo‘, ‘Credit‘],key=str.lower) 忽略大小写排序
sorted([‘bob‘, ‘about‘, ‘Zoo‘, ‘Credit‘],key=str.lower,reverse=True) 反向排序
len(list) : list长度,len([1,2,3])
1. 返回对象的长度，参数可以是序列(比如字符串、字节数组、元组、列表和range对象)，或者是集合(比如字典、集合、不可变集合)
2. 如果参数为其它类型，则其必须实现__len__方法，并返回整数，否则报错。
divmod(a,b): 获取商和余数。 divmod(5,2) >>> (2,1)
pow(a,b) : 获取乘方数。pow(2,3) >>> 8
函数有两个必需参数x,y和一个可选参数z，结果返回x的y次幂乘(相当于x**y)，如果可选参数z有传入值，则返回幂乘之后再对z取模(相当于pow(x,y)%z)。
round(a,b) : 获取指定位数四舍五入后的小数。a代表浮点数，b代表要保留的位数。round(3.1415926,2) >>> 3.14
默认保留0位小数进行取整，返回的是整数。
如果b小于零，则控制了对浮点数的整数部分的后几位进行四舍五入，小数部分全部清0。
range(a[,b]) : 生成一个a到b的数组,左闭右开。 range(1,10) >>> [1,2,3,4,5,6,7,8,9]
range(stop)
range(start, stop[, step])，step是步长，默认是1.
类型相关
int(str) : 转换为int型。int(‘1‘) >>> 1
传入字符串，并指定了进制，则按对应进制将字符串转换成10进制整数。
>>> int(‘07‘,8) 7 >>> int(‘0f‘,16) 15
float(int/str) : 将int型或字符型转换为浮点型。float(‘1‘) >>> 1.0
str(int) : 转换为字符型。str(1) >>> ‘1‘
>>> str(b‘\xe7\x8e\x8b‘, encoding=‘utf-8‘) # 字节转换为字符串 ‘王‘
file_bytes = ‘b‘\\xe6\\x88\\x91\\xe6\\x98‘
str(file_bytes,‘gbk‘) # 当传入encoding不能解码时，会报错(即errors参数默认为strict)
str(file_bytes,‘gbk‘,‘ignore‘) # ‘ignore‘ 忽略级别，字符编码有错，忽略掉.
str(file_bytes,‘gbk‘,‘replace‘) # ‘replace‘ 替换级别，字符编码有错的，替换成？.
bool(int) : 转换为布尔类型。 str(0) >>> False str(None) >>> False
bytes(str,code) : 接收一个字符串，与所要编码的格式，返回一个字节流类型。bytes(‘abc‘, ‘utf-8‘) >>> b‘abc‘ bytes(u‘爬虫‘, ‘utf-8‘) >>> b‘\xe7\x88\xac\xe8\x99\xab‘
bytearray()：根据传入的参数创建一个新的字节数组
list(iterable) : 转换为list。 list((1,2,3)) >>> [1,2,3]
iter(iterable)： 返回一个可迭代的对象。 iter([1,2,3]) >>> <list_iterator object at 0x0000000003813B00>
dict(iterable) : 转换为dict。 dict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)]) >>> {‘a‘:1, ‘b‘:2, ‘c‘:3}
enumerate(iterable) : 根据可迭代对象创建枚举对象。
>>> seasons = [‘Spring‘, ‘Summer‘, ‘Fall‘, ‘Winter‘] >>> list(enumerate(seasons)) [(0, ‘Spring‘), (1, ‘Summer‘), (2, ‘Fall‘), (3, ‘Winter‘)] >>> list(enumerate(seasons, start=1)) #指定起始值 [(1, ‘Spring‘), (2, ‘Summer‘), (3, ‘Fall‘), (4, ‘Winter‘)]
tuple(iterable) : 传入可迭代对象，使用其元素创建一个新的元组。 tuple([1,2,3]) >>>(1,2,3)，tuple(‘123‘) >>>(‘1‘,‘2‘,‘3‘)
set(iterable) : 转换为set。 set([1,4,2,4,3,5]) >>> {1,2,3,4,5} set({1:‘a‘,2:‘b‘,3:‘c‘}) >>> {1,2,3}
frozenset()：根据传入的参数创建一个新的不可变集合
>>> a = frozenset(range(10))
>>> a
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
hex(int) : 转换为16进制。hex(1024) >>> ‘0x400‘
oct(int) : 转换为8进制。 oct(1024) >>> ‘0o2000‘
bin(int) : 转换为2进制。 bin(1024) >>> ‘0b10000000000‘
chr(int) : 转换数字为相应ASCI码字符。 chr(65) >>> ‘A‘
ord(str) : 转换ASCI字符为相应的数字。 ord(‘A‘) >>> 65
complex()：根据传入参数创建一个新的复数
>>> complex(‘1+2j‘) #传入字符串创建复数 (1+2j) >>> complex(1,2) #传入数值创建复数 (1+2j)
memoryview()：根据传入的参数创建一个新的内存查看对象
>>> v = memoryview(b‘abcefg‘) >>> v[1] 98 >>> v[-1] 103
slice()：根据传入的参数创建一个新的切片对象
class slice(stop)
class slice(start, stop[, step])
a=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> c1 = slice(5) # 定义c1 >>> c1 slice(None, 5, None) >>> c2 = slice(2,5) # 定义c2 >>> c2 slice(2, 5, None) >>> c3 = slice(1,10,3) # 定义c3 >>> c3 slice(1, 10, 3) >>> a[c1] # 和a[:5:]结果相同 [0, 1, 2, 3, 4] >>> a[c2] # 和a[2:5:]结果相同 [2, 3, 4] >>> a[c3] # 和a[1:10:3]结果相同 [1, 4, 7]
super()：根据传入的参数创建一个新的子类和父类关系的代理对象，调用父类的方法。
object()：获取一个新的，无特性(geatureless)对象。Object是所有类的基类。它提供的方法将在所有的类型实例中共享。
功能相关：
eval() : 执行一个表达式，或字符串作为运算。 eval(‘1+1‘) >>> 2
exec() : 执行python语句。 exec(‘print("Python")‘) >>> Python
filter(func, iterable) : 通过判断函数fun，筛选符合条件的元素。 filter(lambda x: x>3, [1,2,3,4,5,6]) >>> <filter object at 0x0000000003813828>
map(func, *iterable) : 将func用于每个iterable对象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) >>> [6,8,10]
zip(*iterable) : 将iterable分组合并。返回一个zip对象。 list(zip([1,2,3],[4,5,6])) >>> [(1, 4), (2, 5), (3, 6)]
type()：返回一个对象的类型。
id()： 返回一个对象的唯一标识值。
hash(object)：返回一个对象的hash值，具有相同值的object具有相同的hash值。 hash(‘python‘) >>> 7070808359261009780
help()：调用系统内置的帮助系统。
isinstance()：判断一个对象是否为该类的一个实例。
issubclass()：判断一个类是否为另一个类的子类。
globals() : 返回当前全局变量的字典。
next(iterator[, default]) : 接收一个迭代器，返回迭代器中的数值，如果设置了default，则当迭代器中的元素遍历后，输出default内容。
reversed(sequence) ： 生成一个反转序列的迭代器。 reversed(‘abc‘) >>> [‘c‘,‘b‘,‘a‘]
参考：https://blog.csdn.net/yangxiaoyan12/article/details/87566833
https://www.cnblogs.com/sesshoumaru/p/6140987.html#p2
https://www.cnblogs.com/xiao1/p/5856890.html
原文：https://www.cnblogs.com/wisir/p/12439257.html